集合恍然大明白
作者：互联网
一、集合框架地概述
*
* 1.集合、数组都是对多个数据进行存储操作地结构，简称java容器。
* 说明：此时地存储，主要指地是内存层面地存储，不涉及到持久化地存储(.txt .jpg .avi 数据库中)
*
* 2.1数据在存储多个数据方面地特点
* <一旦初始化以后，其长度就确定了。
* <数组一旦定义好，其元素地类型也就确定了，我们就只能够操作指定类型地数据了。
* 比如：String[] arr, int [], Object[] obj;
* 2.2数组在存储多个数据方面地缺点：
* <一旦初始化以后，其长度就不能修改了。
* <数组中提供地方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。
* <获取数组中实际元素地个数地需求，数组没有现成的属性或方法
* <数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。
二、集合框架结构
|----Collection接口：单列集合，用来存储一个一个的对象。
|----List接口：存储有序的、可重复的数据。 “动态”数组。
|----ArrayList、LinkedList、Vector
|----Set接口：存储无序的、不可重复的数据。 类似高中学的“集合”，无序性、确定性、互异行
|----HashSet、LinkedHashSet、TreeSet
|----Map接口：双列集合，用来存储一对一对(key - value)的数据 类似高中学的函数：y = f(x) y相当于value，一个key不能对应多个value，一个value可以对应多个ket
|----HashMap、LinkedHashMachinep、TreeMap、Hashtable、Properties
三、Collection接口中的方法的使用
15个abstract方法一一展示
public class CollectionTest {
@Test
public void test1(){
Collection coll = new ArrayList();
//1.add(Object e)：将元素e添加到集合coll中
coll.add("AA");
coll.add("BB");
coll.add("123");
coll.add(new Date());
//2.size()
System.out.println(coll.size());//4
//3.addAll(Collection coll):将集合coll中的元素添加到当前集合中
Collection coll1 = new ArrayList();
coll1.add(456);
coll1.add("CC");
coll1.addAll(coll);
System.out.println(coll1.size());
System.out.println(coll1);
//4.clear():清空集合元素
coll1.clear();
//5.isEmpty():判断当前集合是否为空
System.out.println(coll1.size());
System.out.println(coll1.isEmpty());
}
/**
* Collection接口中声明的方法测试2
*
* 结论：
* 向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals()。
*
*/
@Test
public void test2(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new String("Tom"));
coll.add(false);
//Person p = new Person("Jerry",20);
//coll.add(p);
coll.add(new Person("Jerry",20));
//contains(Object obj):判断当前集合是否包含obj
//在判断时，会去调用obj所在类的equals方法。通常要求自定义类重写equals方法。
boolean contains = coll.contains(123); //true
System.out.println(contains);
System.out.println(coll.contains(new String("Tom")));//true 判断的是内容
//System.out.println(coll.contains(p));
System.out.println(coll.contains(new Person("Jerry",20))); //对比的是equals方法
//containsAll(Collection coll1)：判断形参coll1中的所有元素是否都存在于当前集合中。
Collection coll1 = Arrays.asList(123,456);
System.out.println(coll.containsAll(coll1));
}
@Test
public void test3(){
//3.remove(Object obj):从当前集合中移除obj元素
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new String("Tom"));
coll.add(false);
coll.add(new Person("Jerry",20));
boolean remove = coll.remove(1234);
System.out.println(remove);
System.out.println(coll);
coll.remove(new Person("Jerry",20));
System.out.println(coll);
//4.removeAll(Collection coll1)：从当前集合中移除coll1中所有的元素【相当于移除共有的，取差集】
Collection coll1 = Arrays.asList(123,4567);
coll.remove(coll1); //修改了当前集合
System.out.println(coll);
}
@Test
public void test4(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new String("Tom"));
coll.add(false);
coll.add(new Person("Jerry",20));
//5.retainAll(Collection coll1):获取当前集合和coll1集合的交集，并返回给当前集合【修改了当前集合】
// Collection coll1 = Arrays.asList(123,456,789);
// coll.retainAll(coll1);
// System.out.println(coll);
//6.equals(Object obj):要想返回true，需要当前集合和形参集合的元素都相同。
Collection coll1 = new ArrayList();
coll1.add(123);
coll1.add(456); //注意List是有序的，顺序不一样返回false
coll1.add(new String("Tom"));
coll1.add(false);
coll1.add(new Person("Jerry",20));
System.out.println(coll.equals(coll1));
}
@Test
public void test5(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new Person("Jerry",20));
coll.add(new String("Tom"));
coll.add(false);
//7.hashCode()；返回当前对象的哈希值
System.out.println(coll.hashCode());
//8.集合 转换为 数组：toArray()
Object[] arr = coll.toArray();
for (int i = 0; i < arr.length; i++){
System.out.println(arr[i]);
}
//拓展：数组 转换为 集合:调用Arrays类的静态方法asList()
List<String> list = Arrays.asList(new String[]{"AA", "BB", "CC"});
System.out.println(list); //[AA, BB, CC]
List<int[]> list1 = Arrays.asList(new int[]{123, 456});
System.out.println(list1); //[[I@722c41f4] ,一个元素 ，注意此小知识点
// List list2 = Arrays.asList(123, 456);
// System.out.println(list2); //[123, 456]
List list3 = Arrays.asList(new Integer[]{123,456}); //包装类的对象
System.out.println(list3); //[123, 456]
//9.iterator()：返回Iterator接口的实例，用于遍历集合元素。放在IteratorTest.java中测试
}
}
集合元素的遍历操作，使用Iterator接口 【迭代器】
/**
* 集合元素的遍历操作，
* 内部方法:hasNext()和Next()
* @author ldbstart
* @create 2021-03-13 17:39
*/
public class IteratorTest {
@Test
public void test1(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new Person("Jerry",20));
coll.add(new String("Tom"));
coll.add(false);
Iterator iterator = coll.iterator();
//方式一：演示
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// System.out.println(iterator.next()); //报异常java.util.NoSuchElementException
//方式二：
// for (int i =0 ;i < coll.size(); i ++){
// System.out.println(iterator.next());
// }
//方式三：【推荐用法】
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
迭代器的执行原理：
当创建Iterator对象的时候，指针就存在于集合元素最上面。
Iterator遍历集合两种错误写法
@Test
public void test2(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new Person("Jerry",20));
coll.add(new String("Tom"));
coll.add(false);
//Iterator iterator = coll.iterator();
//错误方式一：
// while ((iterator.next()) != null ){
// System.out.println(iterator.next()); //456，Tom，java.util.NoSuchElementException
// }
//错误二：
while (coll.iterator().hasNext()){ //每当调用iterator()方法都会返回一个新的Iterator对象，默认游标都在集合第一个元素之前
System.out.println(coll.iterator().next()); //死循环，不断地输出123
}
}
Iterator迭代器remove方法
@Test
public void test3(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new Person("Jerry",20));
coll.add(new String("Tom"));
coll.add(false);
//删除集合中“Tom”数据
Iterator iterator = coll.iterator();
while (iterator.hasNext()){
Object obj = iterator.next();
if ("Tom".equals(obj)){
iterator.remove();
}
}
iterator = coll.iterator();
//重新遍历
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
注意：
Iterator 可以删除集合的元素 但是是遍历过程中通过迭代器对象的 remove 方法 不是集合对象的 remove 方法 。
如果还未调用 next() 或在上一次调用 next 方法之后已经调用了 remove 方法再调用 remove 都会报IllegalStateException。
增强for循环
jdk5.0新增了foreach循环，用于遍历集合、数组
public class ForTest {
@Test
public void test1(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new Person("Jerry",20));
coll.add(new String("Tom"));
coll.add(false);
//for(集合中元素地类型 局部变量 ： 集合对象)
//内部依然调用了迭代器
for (Object obj : coll) {
System.out.println(obj);
}
}
@Test
public void test2(){
int[] arr = new int[]{1,2,3,4,5,6};
//for(数组元素的类型 局部变量 ：数组对象)
for ( int i : arr){
System.out.println(i);
}
}
//练习题
@Test
public void test3(){
String[] arr = new String[]{"MM","MM","MM"};
//方式一：普通for循环
// for (int i = 0; i < arr.length; i++){
// arr[i] = "GG"; //拿着本身的元素做修改
// }
//方式二：增强for循环
for (String s : arr){
s = "GG"; //s是新的变量，相当于把arr[i]赋值给s
}
for (int i = 0; i < arr.length; i++){
System.out.println(arr[i]);
}
}
}
List接口 “动态”数组
不用关心长度够不够，直接往里添元素。避免了角标越界异常。
* Collection接口：单列集合，用来存储一个一个的对象。
* |----List存储有序的，可重复的数据。
|----ArrayList：作为List接口的主要实现类，jdk1.2；线程不安全，效率高；底层使用Object[ ] elementData存储。
|----LinkedList：jdk1.2，对于频繁的插入和删除操作，使用此类效率比ArrayList高；底层使用的是双向链表存储。
|----Vector：作为List接口的古老实现类jdk1.0，线程安全，效率低；底层也是使用Object[ ] elementData存储
ArrayList源码分析：jdk7情况下
* 1.Collection接口：单列集合，用来存储一个一个的对象。
* |----List存储有序的，可重复的数据。
* |----ArrayList：作为List接口的主要实现类，jdk1.2；线程不安全，效率高；底层使用Object[ ] elementData存储。
* |----LinkedList：jdk1.2，对于频繁的插入和删除操作，使用此类效率比ArrayList高；底层使用的是双向链表存储。
* |----Vector：作为List接口的古老实现类jdk1.0，线程安全，效率低；底层也是使用Object[ ] elementData存储
*
* 2.ArrayList源码分析：
* 2.1jdk7
* 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.2 jdk8中的变化：
* ArrayList list = new ArrayList(); //底层Object [] elementData初始化为{},并没有帮我们创建长度为10的数组
*
* list.add(123);//第一次调用add()时，底层才创建了长度为10的数组，并将数据123添加到elementDate[]
* ...
* 后续和jdk7一样
*
* 小结:jdk7中的ArrayList对象的创建，类似于单例的饿汉式，一上来就给我们造好数组了，而jdk8中的ArrayList的对象的
* 创建类似于单例的懒汉式，延迟了数组的创建，节省了内存。
* 3.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> prev){
* this.item = element;
* this.next = next;
* this.prev = prev;
* }
* }
* 4.Vector底层源码分析：jdk7和jdk8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组。在扩容方面，
* 默认扩容为原来数组长度的2倍。
面试题：比较ArrayList、LinkedList、Vector三者的异同?
同：三各类都实现了List接口，存储数据的特点相同：有序、可重复
不同：见上。
List接口中常用方法：List 除了从 Collection 集合继承的方法外， List 集合里添加了一些根据索引来操作集合元素的 方法 。
void add( int index, Object ele 在 index 位置插入 ele 元素
boolean addAll int index, Collection eles 从 index 位置开始将 eles 中
的所有元素添加进来
Object get( int index): 获取指定 index 位置的元素
int indexOf (Object obj 返回 obj 在集合中首次出现的位置
int lastIndexOf (Object obj 返回 obj 在当前集合中末次出现的位置
Object remove( int index): 移除指定 index 位置的元素，并返回此元素
Object set( int index, Object ele 设置指定 index 位置的元素为 ele
List subList int fromIndex , int toIndex 返回从 fromIndex 到 toIndex位置的子集合
public class ListTest {
@Test
public void test2(){
ArrayList list = new ArrayList();
list.add(123);
list.add(456);
list.add(new Person("Jerry",20));
list.add(new String("Tom"));
list.add(false);
//首次出现的位置
int index = list.indexOf(456);
System.out.println(index);
//int lastIndexOf(Object obj)：返回obj在当前集合末次出现的位置
System.out.println(list.lastIndexOf(456));
//Object remove(int index):删除指定index位置的元素，并返回此元素
Object obj = list.remove(0);
System.out.println(obj);//返回删除的元素
//Object set(int index, Object ele):设置指定index位置的元素为ele
list.set(1, "LDB");
System.out.println(list);
//List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
List list1 = list.subList(2, 4);
System.out.println(list1);
}
@Test
public void test1(){
ArrayList list = new ArrayList();
list.add(123);
list.add(456);
list.add(new Person("Jerry",20));
list.add(new String("Tom"));
list.add(false);
System.out.println(list);
//void add(int index, Object ele):在index位置插入ele元素
list.add(1,"BB"); //在1的位置插入“BB”，后面的元素往后移
System.out.println(list);
//boolean addAll(int index, Collection eles):从index位置开始将eles中所有的元素添加
List list1 = Arrays.asList(1,2,3);
list.addAll(list1);
System.out.println(list.size()); //9
//Object get(int index):获取指定index位置的元素
Object o = list.get(1);
System.out.println(o);
//int indexOf(Object obj):返回obj在集合中首次出现的位置
//int lastIndexOf(Object obj)：返回obj在当前集合末次出现的位置
//Object remove(int index):删除指定index位置的元素，并返回次元素
//Object set(int index, Object ele):设置指定index位置的元素为ele，(后面元素往后移动)
//List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
}
}
三种遍历方式
@Test
public void test3(){
ArrayList list = new ArrayList();
list.add(123);
list.add(456);
list.add(new Person("Jerry",20));
list.add(new String("Tom"));
list.add(false);
//方式一
// Iterator iterator = list.iterator();
// while (iterator.hasNext()){
// System.out.println(iterator.next());
// }
//方式二
for (Object object : list){
System.out.println(object);
}
System.out.println("****************");
//方式三：
for (int i = 0 ; i < list.size(); i++){
System.out.println(list.get(i));
}
}
总结常用方法：
增：add(Object obj)往末尾添加
删：remove(int index)【List接口自己的】 / remove(Object obj)【Collection里的】 注意区分
改：set(int index, Object ele)
查：get(int index)
插：add(int index, Object ele)
长度：size()
遍历：①Iterator迭代器方式 ②增强for循环 ③普通的for循环
标签：add,System,println,coll,恍然,明白,集合,new,out 来源： https://www.cnblogs.com/ldbstart/p/14529347.html