1.Collection接口（线性存储）
(Coolection是一个顶级接口，其实上层还有一个顶级接口Iterable)
对于容器来说collection是容器的一个顶级接口
a、List接口（有序（指的是有下标），可重复）
b、Set接口（ HastSet是无序的，LinkedHashSet 、TreeSet是有序的，不可重复）
c、queue
2、List接口
特点：
1.可以存储不同数据类型
2.长度动态的
3.内存空间不一定是连续的
4.只能存储对象
List接口的实现类: ArrayList ， LinkedList
1）.ArrayList(底层为数组结构)
查、改效率高
ArrayList对象的创建
// 无参构造方法，创建了一个长度为0的的数组
ArrayList list = new ArrayList<>();
//有参构造方法，指定了初始大小，本质上就是创建一个参数大小的数组
//输入一个参数x当x大于0就给定一个x大的数组，等于0就给Java里的一个为0的数组，小于0会报异常
ArrayList list = new ArrayList<>(10);
ArrayList list = new ArrayList<>();
/*1.添加元素
add:
1.先将底层数组扩容
2.将元素复制到数组对应位置
3.返回true
*/
list.add(10);
list.add("asd");
/*
2.为指定位置插入一个元素
第一个参数：指定位置
第二个参数：元素值
*/
list.add(0,12);//相等于把12插入第0位置
System.out.println(list);
//2.get() 获取元素
System.out.println(list.get(0));
/*
3.修改元素 set()
返回值：修改之前的值
*/
Object e = list.set(0,"first"); System.out.println(list.get(0));//打印修改后的第0个元素
System.out.println(e);//打印返回值，返回值为原有值
//4.删除元素 remove()
list.add(0,3);
list.add(0,3);
/*
如果元素为整数
1.remove的参数为int，按照下标删除
2.参数为Integer，按照元素删除,一次只删除一个，删除下标最小的那个
*/
//按照下标删除，返回值为删除的元素
Object element = list.remove(3);
//按照元素删除，返回布尔值
Object element = list.remove(new Integer(3));
//1.求长 size()
System.out.println(list.size());
//2.hasNext()判断是否有下一个元素
//如果有返回true,如果没有返回false
boolean hasNext = iterator.hasNext();
System.out.println(hasNext);
//3.获取下一个元素 next()
iterator.next();
//4.根据元素获取下标，第一次出现的下标 indexOf()
//-1,该元素不存在
int index = list.indexOf("bb");
System.out.println(index);
//5.最后一次出现的位置 lastIndexOf()
System.out.println(list.lastIndexOf("bb"));
//6.判断是否包含某元素 contains()
boolean contains = list.contains("aa");
System.out.println(contains);
//7.删除集合所有的元素 clear()
list.clear();
//8.判断集合是否为空集合， isEmpty true：无元素
boolean isEmpty = list.isEmpty();
System.out.println(isEmpty);
isEmpty与==null的区别
isEmpty 判断的是其中的内容，这时候有容器对象，分配了内存（是一种有值，值=null），如果==null， 这时候没有容器对象，没有分配内存，无值（值不存在）
ArrayList<String> list = new ArrayList<>();
list.add("aa");
list.add("bb");
list.add("cc");
list.add("dd");
//2.迭代器:将Collection集合的遍历统一起来，只用于集合,Iterator是一个接口
Iterator<String> iterator = list.iterator();
//通过迭代器删除元素，不会影响整个遍历过程,
//3.通用迭代器 只能从上往下找
while (iterator.hasNext()) {
String e = iterator.next();
//删除当前迭代到的对象
iterator.remove();
System.out.println(e);
}
System.out.println(list.size());
//4.list集合独有的迭代器
//ListIterstor既能从上往下也能从下往上找
ListIterator<String> listIterator = list.listIterator();
//hasNext()判断是否有下一个，next获取下一个
while (listIterator.hasNext()) { System.out.println(listIterator.next());
}
System.out.println("--------------------");
//haspervious()判断是否有上一个，pervious获取上一个
while (listIterator.hasPrevious()) { System.out.println(listIterator.previous());
}
//迭代器的方法
//添加元素
listIterator.add();
//获取前一个下标
listIterator.previousIndex();
//获取下一个下标
listIterator.nextIndex();
1.子集 subList
/*
第一个参数：起始下标（包含）
第二个参数：结束下标（不包含）
*/
List<String> list2 = list.subList(1,3);
System.out.println(list2);
2.合集 addAll
//将参数集合中所有元素添加到调用方法的集合中
//返回值布尔型
list.addAll(list1);
System.out.println(list1);
//list.addAll(index,c);
3.差集 removeAll
// 将list中list和list1的交集删除
list.removeAll(list1);
System.out.println(list);
4. 交集 retainAll
list.retainAll(list1);
System.out.println(list);
//把一个集合的元素copy到另一个集合中
//可能是笔试题，给两个集合将两个集合中共同的元素去掉
List<String> temp = new ArrayList<>(list);
list.removeAll(list1);
list1.removeAll(temp);
System.out.println(list);
System.out.println(list1);
List<String> list2 = list.addAll(list1);
// string a = new String("a");此时是在堆里开辟了一个新的空间，实际上有两个对象,一个在堆区一个常量池
1.集合转数组
//第一种
Object[] array = list.toArray();
for (Object o : array) {
// 强转类型时判断一下这个类型是包含这个对象，返回true可以强转，false不可以
// if (o instanceof String) {
// }
System.out.println(o);
}
//第二种
String[] arr = new String[list.size()];
list.<String>toArray(arr);
System.out.println("------------");
for (String str : arr) {
System.out.println(str);
}
2.数组转化为集合
/*
小坑
asList：如果参数为基本数据类型数组，就会将整个数组作为集合中的一个元素
如果是对象类型的数组，将数组中的元素转换到集合中
*/
//参数为基本数据类型
int[] array_int = {1,2,3};
List list2 = Arrays.asList(array_int);
System.out.println(list2);
// 参数为对象类型
Integer[] array_integer = {1,2,3};
List list3 = Arrays.asList(array_integer);
System.out.println(list3);
2）、Collections的使用
Coolections : List的操作类
//1、shuffle() 随机排列集合中的元素
Collections.shuffle(list);
System.out.println(list);
//2、sort() 对集合排序
Collections.sort(list);
//3、fill() 将集合中的所有元素替换为同一个元素
Collections.fill(list,100);
System.out.println(list);
//4、frequency() 获取某个元素在集合中出现的个数
int frequency = Collections.frequency(list,100);
System.out.println(frequency);
//5、reverse 将集合中的元素反转
Collections.reverse(list);
System.out.println(list);
//6、swap 将集合中的两个元素进行交换
Collections.swap(list,0,1);
System.out.println(list);
//7、rotate 所有元素平移，正数往右，负数往左
Collections.rotate(list,1);
System.out.println(list);
/*8、copy() 第二个参数集合中的元素将第一个参数集合中对应位置的元素覆盖掉
第二个参数的长度不能超过第一个参数的长度*/
Collections.copy(list,list1);
System.out.println(list);
//9、二分查找(前提必须是一个有序列表)，找到给定元素的下标
int index = Collections.binarySearch(list,3,null);
System.out.println(index);
3）、 比较器Comparable和Comparator的区别
（1）如果对数组要进行排序，那么必须设置排序规则，可以使用Comparable或Comparator接口实现。
（2）Comparable是一个在类定义时实现好的接口。这样此类的对象数组就可以进行排序，在Comparable接口下定义有一个public int compareTo（）方法。
（3）Comparator是专门定义一个指定类的比较规则，属于挽救的比较操作，里面有public int compare（）、public boolean equals（）两个方法
4.LinkedList（底层为双向链表）
增、删效率高, 没有角标
·（1）ArrayList读快 LinkedList写快 ArrayList用的多
因为在List中用的最多的是查找的过程
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
