-
什么是集合
集合、数组都是对多个数据进行存储操作的结构，简称Java容器。
说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储（.txt,.jpg,.avi，数据库中）
-
集合和数组的区别
数组在存储多个数据方面的特点
> 一旦初始化以后，其长度就确定了。
> 数组一旦定义好，其元素的类型也就确定了。我们也就只能操作指定类型的数据了。比如：String[] arr;int[] arr1;Object[] arr2;只能存储对于定义的类型元素
数组在存储多个数据方面的缺点（集合可以很好的解决）
> 一旦初始化以后，其长度就不可修改。
> 数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。
> 获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用
> 数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。
总结
>数组是固定长度的；集合可变长度的。
>数组可以存储基本数据类型，也可以存储引用数据类型；集合只能存储引用数据类型。
>数组存储的元素必须是同一个数据类型；集合存储的对象可以是不同数据类型（其实集合一般存储的数据也是同一类型的）。
-
集合框架（常用集合类）
Collection 单列集合，用来存储一个一个的对象
|——- List 接口：元素按进入先后有序保存，可重复（”动态“数组）
|—————- LinkedList 接口实现类， 底层是链表实现的，增和删比较快，查找和修改比较慢，没有同步， 线程不安全
|—————- ArrayList 接口实现类， 底层是数组实现的， 随机访问，查找和修改快，增和删比较慢， 没有同步，线程不安全
|—————- Vector 接口实现类 底层是数组实现的，同步，线程安全
|———————- Stack 是Vector类的实现类
|——- Set接口：存储无序的、不可重复的数据 -->高中讲的“集合”
|—————- HashSet 使用hash表（数组）存储元素
|————————- LinkedHashSet 链表维护元素的插入次序，可以保证存储的元素唯一
|—————-TreeSet 底层是二叉树算法实现，元素排好序
Map接口：双列集合，用来存储一对(key - value)一对的数据 -->高中函数：y = f(x)
|———- Hashtable 接口实现类， 同步， 线程安全
|———- HashMap 接口实现类 ，没有同步， 线程不安全-
|—————–- LinkedHashMap 双向链表和哈希表实现
|—————–- WeakHashMap
|——–- TreeMap 红黑树对所有的key进行排序
|———- IdentifyHashMap
-
Collection接口中的方法的使用
在集合末尾添加元素——boolean add（E e）
@Test
public void test1(){
Collection coll = new ArrayList();
coll.add("aaa");
coll.add(123);//自动装箱
coll.add(new Date());
System.out.println(coll);
}获取添加的元素的个数——int size（）
System.out.println(coll.size());//3将集合中的元素添加到当前的集合中——boolean addll（Collection c）
Collection coll1 = new ArrayList();
coll1.add("bbb");
coll.addAll(coll1);
System.out.println(coll);//[aaa, 123, Fri Jun 10 15:30:17 CST 2022, bbb]清空集合中所有的元素——void clear（）
coll.clear();
System.out.println(coll);//[]判断当前集合是否为空——boolean isEmpty（）
System.out.println(coll.isEmpty());//true判断集合中是否包含某元素——boolean contains（Object o）
Collection coll = new ArrayList();
coll.add(123);
coll.add(new String("嘻戏i"));
coll.add(new Person("嘻戏i",31));
System.out.println(coll.contains(123));//true
System.out.println(coll.contains(new String("嘻戏i")));//true
//我们在判断时会调用obj对象所在类的equals()。Person类未重写equals方法则该处为false，反之为true
System.out.println(coll.contains(new Person("嘻戏i",31)));//false -->true判断某一集合中的所有元素是否都存在于当前集合中——boolean containsAll（Collection c）
Collection coll1 = Arrays.asList(123,"嘻戏i");
System.out.println(coll.containsAll(coll1));//true从集合中移除某一元素——boolean remove（Object o）
coll.remove(123);
System.out.println(coll);//[嘻戏i, Person{name='嘻戏i', age=31}]从集合中移除某一集合中所有的元素（差集）——boolean removeAll(Collection c)
coll.removeAll(coll1);
System.out.println(coll);//[Person{name='嘻戏i', age=31}]去除和coll1相同的元素获取当前集合和另一集合的交集，并返回给当前集合boolean retainAll(Collection c)
Collection coll = new ArrayList();
coll.add(123);
coll.add("嘻戏i");
coll.add(new Person("嘻戏i",31));
coll.add(false);
Collection coll1 = Arrays.asList(123,"嘻戏i","aaa");
coll.retainAll(coll1);
System.out.println(coll);//[123, 嘻戏i]
System.out.println(coll1);//[123, 嘻戏i, aaa]判断当前集合和形参集合是否相同——boolean equals（Object o）
boolean equals = coll.equals(coll1);
//要想返回true 需要当前集合和形参集合的元素都相同。(因为我们这里使用的是collection子类ArrayList是有序的，所有元素的位置也需要一致)
System.out.println(equals);返回当前对象的哈希值——int hashcode（）
int i = coll.hashCode();
System.out.println(i);集合转数组——Object[] toArray（）
Collection coll = new ArrayList();
coll.add("嘻戏i");
coll.add(123);
coll.add(new Person("嘻戏i",31));
Object[] objects = coll.toArray();
for (int i = 0; i < objects.length; i++) {
System.out.println(objects[i]);
}数组转集合——调用Arrays类的静态方法asList()
List list = Arrays.asList(new String[]{"aa","bb","cc"});
System.out.println(list);//[aa, bb, cc]
//基本数据类型的数组转化成集合时，会将整个数组默认一个整体
List list1 = Arrays.asList(new int[]{111,222,333});
System.out.println(list1);//[[I@3d82c5f3]
List list2 = Arrays.asList(new Integer[]{111,222,333});
System.out.println(list2);//[111, 222, 333]
遍历集合元素：迭代器——Iterator iterator（）
public void test5() {
Collection coll = new ArrayList();
coll.add("嘻戏");
coll.add(123);
coll.add(new Person("嘻戏", 28));
Iterator iterator = coll.iterator();//获取迭代器
while (iterator.hasNext()) { //hasNext():判断是否还有下一个元素
System.out.println(iterator.next()); //next():①指针下移 ②将下移以后集合位置上的元素返回
}
}-
遍历集合元素的方法：
使用迭代器Iterator
public void test5() {
Collection coll = new ArrayList();
coll.add("嘻戏");
coll.add(123);
coll.add(new Person("嘻戏", 28));
Iterator iterator = coll.iterator();//获取迭代器
//方式一：不推荐
// for (int i = 0; i < coll.size(); i++) {
// System.out.println(iterator.next());
// }
//方式二：推荐
while (iterator.hasNext()) { //hasNext():判断是否还有下一个元素
System.out.println(iterator.next()); //next():①指针下移 ②将下移以后集合位置上的元素返回
}
使用迭代器Iterator的错误方式
下面三种错误方式代码用到的集合
Collection coll = new ArrayList();
coll.add("嘻戏");
coll.add(123);
coll.add(new Person("嘻戏", 28));错误方式1： 报异常：NoSuchElementException
//方式1.1
Iterator iterator1 = coll.iterator();
while (iterator1.next() != null){
System.out.println(iterator1.next());
}
//方式1.2
System.out.println(iterator.next());
System.out.println(iterator.next());
//报异常：NoSuchElementException
System.out.println(iterator.next());错误方式2 一直无限循环下去
//集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。
while (coll.iterator().hasNext()){
System.out.println(coll.iterator().next());
}//错误方式3 关于Iterator中的remove()
//如果还未调用next()或在上一次调用 next 方法之后已经调用了 remove 方法，再调用remove都会报IllegalStateException。
Iterator iterator2 = coll.iterator();
while (iterator2.hasNext()){
// iterator2.remove(); //报异常：IllegalStateException
//正确操作：删除集合中的new Person("嘻戏",28)
Object obj = iterator2.next();
if (new Person("嘻戏",28).equals(obj)){
iterator2.remove();
}
}
iterator2 = coll.iterator();
while (iterator2.hasNext()){
System.out.println(iterator2.next());
}增强for循环遍历集合元素
Collection coll = new ArrayList();
coll.add(123);
coll.add("嘻戏");
coll.add(new Person("嘻戏",28));
//for(集合元素的类型 局部变量 : 集合对象)
//内部仍然调用了迭代器。
for (Object obj: coll) {
System.out.println(obj);
}
System.out.println("*****************");
//for循环和增加for循环
String[] arr = new String[]{"MM","MM","MM"};
for (int i = 0; i < arr.length; i++) {
// arr[i] = "GG";//改变了字符串arr
}
for (String s :
arr) {
s = "GG";//只改变了局部变量s，未改变字符串arr
// System.out.println(s);
}
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}-
List接口框架
|----Collection接口：单列集合，用来存储一个一个的对象
|----List接口：存储有序的、可重复的数据。 -->“动态”数组,替换原有的数组
|----ArrayList：作为List接口的主要实现类；线程不安全的，效率高；底层使用Object[] elementData存储
|----LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储
|----Vector：作为List接口的古老实现类；线程安全的，效率低；底层使用Object[] elementData存储
ArrayList的源码分析
1 jdk 7情况下
ArrayList list = new ArrayList();//底层创建了长度是10的Object[]数组elementData
list.add(123);//elementData[0] = new Integer(123);
list.add(11);//如果此次的添加导致底层elementData数组容量不够，则扩容。
默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中。
结论：建议开发中使用带参的构造器：ArrayList list = new ArrayList(int capacity)
2 jdk 8中ArrayList的变化：
ArrayList list = new ArrayList();//底层Object[] elementData初始化为{}.并没有创建长度为10的数组
list.add(123);//第一次调用add()时，底层才创建了长度10的数组，并将数据123添加到elementData[0]
后续的添加和扩容操作与jdk 7 无异。
3 小结：jdk7中的ArrayList的对象的创建类似于单例的饿汉式，而jdk8中的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。
LinkedList的源码分析
LinkedList list = new LinkedList(); 内部声明了Node类型的first和last属性，默认值为null
list.add(123);//将123封装到Node中，创建了Node对象。
其中，Node定义为：体现了LinkedList的双向链表的说法
private static class Node<E> {
E item;
Node<E> next;
Node<E> prev;
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}Vector的源码分析
jdk7和jdk8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组。在扩容方面，默认扩容为原来的数组长度的2倍。
总结
ArrayList、LinkedList、Vector三者的异同：
同：三个类都是实现了List接口，存储数据的特点相同：存储有序的、可重复的数据
异:通过上面的源代码分析
List接口中的常用方法
增：
在index位置插入元素 ——void add(int index, Object ele)
list.add(1,456);从index位置开始将另外集合中的所有元素添加进来 ——boolean addAll(int index, Collection eles)
List list1 = Arrays.asList(1,2,3);
//从list索引2的位置开始将list1中的所有元素添加进来
list.addAll(2,list1);
//从list末尾的位置开始将list1中的所有元素当做一个整体添加进来
list.add(list1);删：
移除指定索引位置的元素，并返回此元素——Object remove(int index) / boolean remove(Object obj)
//删除list集合中索引为2的元素，并返回该元素
Object Obj = list.remove(2);
System.out.println(Obj);
//删除list集合中list1集合，有就返回true，没有返回false
boolean obj1 = list.remove(list1);
System.out.println(obj1);改：
设置指定索引位置的元素为其他元素——Object set(int index, Object ele)
Object obj2 = list.set(3, 33);
System.out.println(obj2);查：
获取指定索引位置的元素 ——Object get(int index)
Object obj3 = list.get(3);
System.out.println(obj3);获取集合长度——int size()
int size = list.size();返回obj在集合中首次出现的位置（集合中不存在查询的元素返回-1）——int indexOf(Object obj)
int i = list.indexOf(123);返回obj在当前集合中末次出现的位置——int lastIndexOf(Object obj)
int i2 = list.lastIndexOf(123);返回从fromIndex到toIndex位置的子集合（左闭右开）——List subList(int fromIndex, int toIndex)
List list2 = list.subList(1, 4);List集合遍历
Iterator迭代器方式
Iterator iterator = list.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}增强for循环
for (Object obj : list) {
System.out.println(obj);
}普通for循环（List集合有索引，结合get方法，可以用普通for循环）
for (int j = 0; j < list.size(); j++) {
System.out.println(list.get(j));
}-
Set接口的框架
|----Collection接口：单列集合，用来存储一个一个的对象
|----Set接口：存储无序的、不可重复的数据 -->高中讲的“集合”
|----HashSet：作为Set接口的主要实现类；线程不安全的；可以存储null值
|----LinkedHashSet：作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历
对于频繁的遍历操作，LinkedHashSet效率高于HashSet.
|----TreeSet：可以按照添加对象的指定属性，进行排序。
说明
1. Set接口中没有额外定义新的方法，使用的都是Collection中声明过的方法。
2.1 要求：向Set(主要指：HashSet、LinkedHashSet)中添加的数据，其所在的类一定要重写hashCode()和equals()
2.2要求：重写的hashCode()和equals()尽可能保持一致性：相等的对象必须具有相等的散列码 重写两个方法的小技巧：对象中用作 equals() 方法比较的 Field，都应该用来计算 hashCode 值。
Set集合存储元素的特征
存储无序的、不可重复的数据
1. 无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定的。
2. 不可重复性：保证添加的元素按照equals()判断时，不能返回true.即：相同的元素只能添加一个。
Set集合添加元素的过程分析（以HashSet为例）
我们向HashSet中添加元素a,首先调用元素a所在类的hashCode()方法，计算元素a的哈希值，
此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为：索引位置），判断
数组此位置上是否已经有元素：
如果此位置上没有其他元素，则元素a添加成功。 --->情况1
如果此位置上有其他元素b(或以链表形式存在的多个元素），则比较元素a与元素b的hash值：
如果hash值不相同，则元素a添加成功。--->情况2
如果hash值相同，进而需要调用元素a所在类的equals()方法：
equals()返回true,元素a添加失败
equals()返回false,则元素a添加成功。--->情况3
对于添加成功的情况2和情况3而言：元素a 与已经存在指定索引位置上数据以链表的方式存储。
jdk 7 :元素a放到数组中，指向原来的元素。（七上）
jdk 8 :原来的元素在数组中，指向元素a（八下）
HashSet底层：数组+链表的结构。
LinkedHashSet
LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据。
优点：对于频繁的遍历操作，LinkedHashSet效率高于HashSet
public void test2(){
Set set = new LinkedHashSet();
set.add(456);
set.add(123);
set.add(123);
set.add("AA");
set.add("CC");
set.add(new User("Tom",12));
set.add(new User("Tom",12));
set.add(129);
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}TreeSet
说明
1.可以按照添加对象的指定属性，进行排序。但向TreeSet中添加的数据，要求是相同类的对象。
//添加失败：不能添加不同类的对象
TreeSet set = new TreeSet();
set.add(123);
set.add("aaa");
set.add(new Person("嘻戏",28));2.两种排序方式：自然排序（实现Comparable接口） 和 定制排序（Comparator）
3.自然排序中，比较两个对象是否相同的标准为：compareTo()返回0.不再是equals().
4.定制排序中，比较两个对象是否相同的标准为：compare()返回0.不再是equals().
自然排序
person类：
public class Person implements Comparable {
private String name;
private int age;
public Person(){}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age && Objects.equals(name, person.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
//按照姓名从大到小排列,年龄从小到大排列
@Override
public int compareTo(Object o) {
if (o instanceof Person){
Person p = (Person) o;
int compareNum = -this.name.compareTo(p.name);
if (compareNum != 0){
return compareNum;
}else {
return Integer.compare(this.age,p.age);
}
}else {
throw new RuntimeException("输入的类型不匹配");
}
}
}TreeSet集合：
TreeSet set = new TreeSet();
set.add(new Person("嘻戏",33));
set.add(new Person("张三",28));
set.add(new Person("李四",28));
set.add(new Person("王二",55));
set.add(new Person("嘻戏",26));
Iterator iterator = set.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());//java.lang.ClassCastException
}定制排序
Comparator comparator = new Comparator() {
//按照年龄从小到大排列
@Override
public int compare(Object o1, Object o2) {
if (o1 instanceof Person && o2 instanceof Person){
Person p1 = (Person) o1;
Person p2 = (Person) o2;
return Integer.compare(p1.getAge(),p2.getAge());
}else {
throw new RuntimeException("输入的数据类型不匹配");
}
}
};
TreeSet set = new TreeSet(comparator);
set.add(new Person("嘻戏",26));
set.add(new Person("嘻戏",33));
set.add(new Person("张三",28));
set.add(new Person("李四",28));//该条元素未存储进去
set.add(new Person("王二",55));
Iterator iterator = set.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());//java.lang.ClassCastException
}
1475
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
