1.2ArrayList集合方法//创建ArrayList集合对象
ArrayListlist = new ArrayList<>(); <>是一种泛型 泛型:是一种数据安全的做法,规定集合应该存储怎样的数据类型
为什么要在集合中添加泛型?
方便管理
package com.qf.arraylist_class;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class Test02 {
public static void main(String[] args) {
//创建ArrayList集合对象
ArrayList list = new ArrayList<>();
//添加元素
list.add("椎名空");
list.add("张三");
list.add("天使萌");
list.add("佐佐木希");
list.add("古川伊织");
list.add("京香Julia");
//在指定下标上插入元素
list.add(3, "上原亚衣");
//通过下标设置元素
list.set(1, "王五");
//将newList1中所有的元素添加到list集合的末尾
ArrayList newList1 = new ArrayList<>();
Collections.addAll(newList1, "aaa","bbb","ccc","ccc");//利用集合工具类对集合进行批量添加
list.addAll(newList1);
//将newList2中所有的元素添加到list集合指定下标的位置
ArrayList newList2 = new ArrayList<>();
Collections.addAll(newList2, "xxx","yyy","zzz","zzz");//利用集合工具类对集合进行批量添加
list.addAll(3, newList2);
//通过下标获取元素
String name = list.get(1);
System.out.println("通过下标获取元素:" + name);
//获取元素个数
int size = list.size();
System.out.println("获取元素个数:" + size);
//清空集合中所有的元素
//list.clear();
System.out.println("判断集合中是否有指定元素:" + list.contains("天使萌"));//true
System.out.println("判断集合中是否有指定集合(判断包含关系):" + list.containsAll(newList1));//true
System.out.println("判断集合中是否没有元素:" + list.isEmpty());//false (true-没有元素 false-有元素)
System.out.println("获取元素在集合中第一次出现的下标:" + list.indexOf("zzz"));//5
System.out.println("获取元素在集合中最后一次出现的下标:" + list.lastIndexOf("zzz"));//6
//依据元素删除元素
list.remove("上原亚衣");
//依据下标删除元素
list.remove(1);
//去除交集
list.removeAll(newList1);
//保留交集
list.retainAll(newList2);
//从开始下标处(包含)截取到结束下标处(不包含),返回新的集合
List subList = list.subList(1, 3);
//将集合转换为数组
Object[] array = subList.toArray();
System.out.println(Arrays.toString(array));
System.out.println("---------------");
//遍历1 - for循环
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
System.out.println("---------------");
//遍历2 - foreach
for (String element : list) {
System.out.println(element);
}
System.out.println("---------------");
//遍历3 - Iterator
Iterator it = list.iterator();
while(it.hasNext()){//判断是否有下一个可迭代的元素
String next = it.next();//返回下一个元素
System.out.println(next);
}
System.out.println("---------------");
//遍历4 - ListIterator
ListIterator listIterator = list.listIterator();
while(listIterator.hasNext()) {//判断是否有下一个可迭代的元素
String next = listIterator.next();//返回下一个元素
System.out.println(next);
}
}
}
1.3泛型市列
package com.qf.generic01;
/**
* <> -- 泛型
* E - element - 元素
* T - type - 类型
* K - key - 键
* V - value-值
*/
public class MyArrayList {
public void add(E e){
}
}
package com.qf.generic01;
import java.util.ArrayList;
public class Test01 {
public static void main(String[] args) {
/**
* 需求:模拟ArrayList底层泛型的使用场景
*
* 泛型的类型必须是引用数据类型
*/
ArrayList list = new ArrayList<>();
list.add(100);
System.out.println("---------");
MyArrayList arrayList = new MyArrayList<>();
arrayList.add(100);
}
}
1.4泛型举例
1.4.1定义泛型方法
package com.qf.generic02;
//所有管理系统的标准
public interface ManagerSystem {
public int add(T t);
public int delete(T t);
}
1.4.2实现类重写接口方法
package com.qf.generic02;
public class BookManagerSystem implements ManagerSystem{
@Override
public int add(Book t) {
// TODO Auto-generated method stub
return 0;
}
@Override
public int delete(Book t) {
// TODO Auto-generated method stub
return 0;
}
}
package com.qf.generic02;
public class StudentManagerSystem implements ManagerSystem{
@Override
public int add(Student t) {
// TODO Auto-generated method stub
return 0;
}
@Override
public int delete(Student t) {
// TODO Auto-generated method stub
return 0;
}
}
1.5泛型限定
package com.qf.generic03;
import java.util.ArrayList;
public class Test01 {
public static void main(String[] args) {
}
//?表示任何引用类型
public static ArrayList> method01(){
//ArrayList
二、迭代
2.1遍历集合
foreach底层由迭代器实现
package com.qf.iterator;
import java.util.ArrayList;
public class Test01 {
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
list.add("麻生希");
list.add("椎名空");
list.add("天使萌");
list.add("爱田奈奈");
for (String element : list) {
System.out.println(element);
}
//foreach底层
// String element;
// for(Iterator it = list.iterator();it.hasNext();System.out.println(element)){
// element = it.next();
// }
}
}
2.2Iterator遍历集合
package com.qf.iterator;
import java.util.ArrayList;
import java.util.Iterator;
public class Test02 {
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
list.add("麻生希");
list.add("椎名空");
list.add("天使萌");
list.add("爱田奈奈");
Iterator it = list.iterator();
while (it.hasNext()) {
String element = it.next();
System.out.println(element);
}
}
}
2.3Iterator遍历集合到某某值时删除该值
package com.qf.iterator;
import java.util.ArrayList;
import java.util.Iterator;
public class Test03 {
public static void main(String[] args) {
/**
* 知识点:Iterator
*
* 需求:使用Iterator遍历集合,在遍历到"椎名空"是删除该元素
*
* 总结:Iterator可以遍历集合时删除
*/
ArrayList list = new ArrayList<>();
list.add("麻生希");
list.add("椎名空");
list.add("天使萌");
list.add("爱田奈奈");
Iterator it = list.iterator();
while (it.hasNext()) {
String element = it.next();
if(element.equals("椎名空")){
//ConcurrentModificationException - 当前修改异常
//报错原因:ArrayList的 *** 作数 和 Itr的 *** 作数不一致
//设计思想:使用迭代器是遍历数据,如果你在遍历时 *** 作数据,会导致遍历数据有误,严谨在遍历时使用集合删除元素,要删除都是使用的迭代器删除元素
//list.remove(element);
it.remove();
}
}
for (String element : list) {
System.out.println(element);
}
}
}
2.4ListIterator遍历集合
package com.qf.iterator;
import java.util.ArrayList;
import java.util.ListIterator;
public class Test04 {
public static void main(String[] args) {
/**
* 知识点:ListIterator
*
* 需求:使用ListIterator遍历集合
*
* 总结:ListIterator可以像Iterator一样遍历集合
*/
ArrayList list = new ArrayList<>();
list.add("麻生希");
list.add("椎名空");
list.add("天使萌");
list.add("爱田奈奈");
ListIterator listIterator = list.listIterator();
while(listIterator.hasNext()){
String next = listIterator.next();
System.out.println(next);
}
}
}
2.5使用ListIterator遍历集合,遍历到某某元素时删除元素
package com.qf.iterator;
import java.util.ArrayList;
import java.util.ListIterator;
public class Test05 {
public static void main(String[] args) {
/**
* 知识点:ListIterator
*
* 需求:使用ListIterator遍历集合,遍历到"椎名空"时删除元素
*
* 总结:ListIterator可以像Iterator一样遍历集合时删除元素
*/
ArrayList list = new ArrayList<>();
list.add("麻生希");
list.add("椎名空");
list.add("天使萌");
list.add("爱田奈奈");
ListIterator listIterator = list.listIterator();
while(listIterator.hasNext()){
String next = listIterator.next();
if(next.equals("椎名空")){
listIterator.remove();
}
}
for (String str : list) {
System.out.println(str);
}
}
}
2.6使用ListIterator遍历集合,遍历到某某元素时添加元素
package com.qf.iterator;
import java.util.ArrayList;
import java.util.ListIterator;
public class Test06 {
public static void main(String[] args) {
/**
* 知识点:ListIterator
*
* 需求:使用ListIterator遍历集合,遍历到"椎名空"时添加元素
*
* 总结:ListIterator可以在遍历集合时添加元素
*/
ArrayList list = new ArrayList<>();
list.add("麻生希");
list.add("椎名空");
list.add("天使萌");
list.add("爱田奈奈");
ListIterator listIterator = list.listIterator();
while(listIterator.hasNext()){
String next = listIterator.next();
if(next.equals("椎名空")){
listIterator.add("罗菌鱼");
}
}
for (String str : list) {
System.out.println(str);
}
}
}
2.7使用ListIterator遍历集合,遍历到某某元素时替换元素
package com.qf.iterator;
import java.util.ArrayList;
import java.util.ListIterator;
public class Test07 {
public static void main(String[] args) {
/**
* 知识点:ListIterator
*
* 需求:使用ListIterator遍历集合,遍历到"椎名空"时替换元素
*
* 总结:ListIterator可以在遍历集合时替换元素
*/
ArrayList list = new ArrayList<>();
list.add("麻生希");
list.add("椎名空");
list.add("天使萌");
list.add("爱田奈奈");
ListIterator listIterator = list.listIterator();
while(listIterator.hasNext()){
String next = listIterator.next();
if(next.equals("椎名空")){
listIterator.set("罗菌鱼");
}
}
for (String str : list) {
System.out.println(str);
}
}
}
2.8使用ListIterator实现指定下标开始遍历集合
package com.qf.iterator;
import java.util.ArrayList;
import java.util.ListIterator;
public class Test08 {
public static void main(String[] args) {
/**
* 知识点:ListIterator
*
* 需求:使用ListIterator实现指定下标开始遍历集合
*
* 总结:ListIterator可以指定下标开始遍历
*/
ArrayList list = new ArrayList<>();
list.add("麻生希");
list.add("椎名空");
list.add("天使萌");
list.add("爱田奈奈");
ListIterator listIterator = list.listIterator(1);
while(listIterator.hasNext()){
String next = listIterator.next();
System.out.println(next);
}
}
}
2.9使用ListIterator实现倒叙遍历集合
package com.qf.iterator;
import java.util.ArrayList;
import java.util.ListIterator;
public class Test09 {
public static void main(String[] args) {
/**
* 知识点:ListIterator
*
* 需求:使用ListIterator实现倒叙遍历集合
*
* 总结:ListIterator可以实现倒叙遍历集合
*/
ArrayList list = new ArrayList<>();
list.add("麻生希");
list.add("椎名空");
list.add("天使萌");
list.add("爱田奈奈");
ListIterator listIterator = list.listIterator(list.size());
while(listIterator.hasPrevious()){//判断是否有上一个可迭代的元素
String previous = listIterator.previous();//获取上一个元素
System.out.println(previous);
}
/**
* Iterator vs ListIterator
*
* Iterator:正序遍历、删除元素
* ListIterator:正序遍历、指定下标开始遍历、倒叙遍历、删除元素、添加元素、替换元素
*
* 注意:List接口下的实现类才能获取ListIterator
*/
}
}
3.0 LinkedList之队列模式
package com.qf.linkedlist_class;
import java.util.LinkedList;
public class Test02 {
public static void main(String[] args) {
/**
* 知识点:LinkedList 之 队列模式
*
* 队列模式:先进先出
*/
LinkedList list = new LinkedList<>();
list.add("罗非鱼1");
list.add("罗非鱼2");
list.add("罗非鱼3");
list.add("罗非鱼4");
list.add("罗非鱼5");
while(!list.isEmpty()){//判断集合中是否有元素
//删除第一个元素,并返回
String element = list.removeFirst();
System.out.println(element);
}
System.out.println("集合中的元素个数:" + list.size());//0
}
}
3.1LinkedList 之栈模式
package com.qf.linkedlist_class;
import java.util.LinkedList;
public class Test03 {
public static void main(String[] args) {
/**
* 知识点:LinkedList 之栈模式
*
* 栈模式:先进后出/后进先出
*/
LinkedList list = new LinkedList<>();
list.add("罗菌鱼1");
list.add("罗菌鱼2");
list.add("罗菌鱼3");
list.add("罗菌鱼4");
list.add("罗菌鱼5");
while(!list.isEmpty()){//判断集合中是否有元素
//删除最后一个元素,并返回
String element = list.removeLast();
System.out.println(element);
}
System.out.println("集合中的元素个数:" + list.size());//0
}
}
3.2HashSet
package com.qf.hashset_class;
import java.util.HashSet;
public class Test02 {
public static void main(String[] args) {
/**
* 知识点:理解HashSet的无序且不可重复
*
* 存入顺序:
* 1.获取对象的hash值 -- hashCode()
* 2.通过散列算法计算出在数组中的下标
* 2.1 下标上没有元素 --- 直接加入
* 2.2 下标上有元素 - 判断两个对象是否相同(hash、==、equals)
* 2.2.1 相同对象,不存(达到去重的效果)
* 2.2.2 不同对象,就存储
* 取出顺序:
* 从头到尾遍历数组
*/
HashSet set = new HashSet<>();
set.add("罗志祥");
set.add("张柏芝");
set.add("阿娇");
set.add("陈冠希");
set.add("吴亦凡");
set.add("吴亦凡");
for (String str : set) {
System.out.println(str);
}
}
}
3.3Vector
package com.qf.vector_class;
import java.util.Enumeration;
import java.util.Vector;
public class Test02 {
public static void main(String[] args) {
/**
* 知识点:Vector的发展史
*
* Vector是JDK1.0就有的集合类(元老级别的类),但是还没有集合框架的概念
* JDK1.2才开始推广集合框架的概念,当时大部分程序员习惯使用Vector,所以Java又给Vector多实现了一个接口(List)
* 所以才将其保留下来,所以Vector类中有很多老的方法(这些方法很喜欢使用element来命名)
*
* Vector是一个线程安全的类
*/
Vector v = new Vector<>();
v.addElement("张三1");
v.addElement("张三2");
v.addElement("张三3");
v.addElement("张三4");
v.addElement("张三5");
v.addElement("张三6");
v.removeElementAt(1);//根据下标删除元素
v.removeElement("李林俊6");//根据元素删除元素
Enumeration elements = v.elements();
while(elements.hasMoreElements()){
String nextElement = elements.nextElement();
System.out.println(nextElement);
}
}
}
3.4Stack
package com.qf.stack_class;
import java.util.Stack;
public class Test01 {
public static void main(String[] args) {
/**
* 知识点:Stack
* 特点:栈模式 - 先进后出
*
* class Stack extends Vector
*/
Stack stack = new Stack<>();
//将元素压入栈顶
stack.push("李林俊1");
stack.push("李林俊2");
stack.push("李林俊3");
stack.push("李林俊4");
stack.push("李林俊5");
//获取栈顶元素
String peek = stack.peek();
System.out.println(peek);//李林俊5
//删除栈顶元素,并返回
//String pop = stack.pop();
//System.out.println(pop);//李林俊5
//查看该元素距离栈顶位置(从1开始)
int search = stack.search("李林俊1");
System.out.println("查看该元素距离栈顶位置(从1开始):" + search);
//遍历
while(!stack.empty()){//有元素-false 没有元素-true
String pop = stack.pop();
System.out.println(pop);
}
}
}
欢迎分享,转载请注明来源:内存溢出
评论列表(0条)