什么是集合

概念：对象的容器，定义了对多个对象进行操作的常用方法。可以实现数组的功能。和数组的区别： 数组长度固定，集合长度不固定数组可以存储基本类型和引用类型，集合只能存储引用类型 位置：java.util.*

Collection体系集合

Collection父接口

特点：代表一组任意的对象，无序、无下标、不能重复。方法：

collection接口的使用

1.直接添加字符串

import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; /** * Collection接口的使用 * （1）添加元素 * （2）删除元素 * （3）遍历元素 * （4）判断 * */ public class Demo01 { public static void main(String[] args) { //创建集合 Collection collection = new ArrayList(); // （1）添加元素 collection.add("苹果"); collection.add("西瓜"); collection.add("榴莲"); System.out.println("元素个数："+ collection.size()); System.out.println(collection); //（2）删除元素 /* collection.remove("榴莲"); System.out.println("删除之后："+ collection.size());*/ //（3）遍历元素【重点】 System.out.println("======================================"); //3.1增强for循环 for (Object object:collection) { System.out.println(object); } System.out.println("======================================"); //3.2使用迭代器（专门用来遍历集合的一种方式） //hasNext（）；有没有下一个元素 //next（）；获取下一个元素 //remove（）；删除当前元素 Iterator it =collection.iterator(); while(it.hasNext()){ String s =(String)it.next(); System.out.println(s); //迭代过程中不能使用collection删除方法 // collection.remove(s); // it.remove(); } System.out.println("元素个数："+collection.size()); //（4）判断 System.out.println(collection.contains("西瓜")); System.out.println(collection.isEmpty()); } }

2.添加对象

import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; /**Collection保存学生信息 * * */ public class Demo02 { public static void main(String[] args) { //新建Collection对象 Collection collection = new ArrayList(); Student s1 = new Student("张三",20); Student s2 = new Student("张无忌",18); Student s3 = new Student("王三",22); //1.添加数据 collection.add(s1); collection.add(s2); collection.add(s3); System.out.println("元素个数："+collection.size()); System.out.println(collection); //2.删除数据 //collection.remove(s1); //collection.clear(); System.out.println("删除之后："+collection.size()); //3.遍历 //3.1增强for for (Object object:collection) { Student s = (Student)object; System.out.println(s); } System.out.println("===================================="); //3.2迭代器hasNext（）；next（）；remove（） //如果我想 看到Student 的 名字和年龄 ，就要用到getname和getage两个方法，但是 上级不能直接调用下级的方法，所以这里涉及到了向下转型。 //Student s= (Student)it.next(); //存在集合中的元素类型为 Object 类对象 ，变成Student类对象，才能调用Student类中的 getName（） 和 getAge（）方法。 // Object类 为 Student类的 父类 ， 父类不能直接调用子类中的方法 。 Iterator it =collection.iterator(); while(it.hasNext()) { Student s = (Student) it.next(); System.out.println(s.getName()+"..."+s.getAge()); } //4.判断 System.out.println(collection.contains(s1)); System.out.println(collection.isEmpty()); } } /* * 学生类 * * */ public class Student { private String name; private int age; public Student() { } public Student(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 "Student{" + "name='" + name + '\'' + ", age=" + age + '}'; } }

list子接口

特点：有序、有下标、元素可以重复方法： void add（int index，object o）//在index位置插入对象boolean addAll(int index,Collection c)//将一个集合中的元素添加到此集合中index位置Object get（int index）//返回集合中指定位置的元素。List subList（int formIndex，int toIndex）//返回fromIndex和toIndex之间的集合元素 import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.ListIterator; /** * List子接口的使用 * 特点：有序、有下标、可以重复 * */ public class Demo03 { public static void main(String[] args) { //先创建集合对象 List list = new ArrayList<>(); //1.添加元素 list.add("苹果"); list.add("小米"); list.add(0,"华为"); System.out.println("元素个数："+list.size()); System.out.println(list); //2.删除元素 /*list.remove("苹果"); System.out.println("删除之后："+list.size()); System.out.println(list);*/ System.out.println("======================================="); //3.遍历 //3.1使用for循环 System.out.println("-------3.1使用for循环------------"); for (int i = 0; i <list.size() ; i++) { System.out.println(list.get(i)); } //3.2增强for System.out.println("-------3.2使用增强for------------"); for (Object object:list) { System.out.println(object); } //3.3使用迭代器 System.out.println("-------3.3使用迭代器------------"); Iterator it = list.iterator(); while(it.hasNext()){ Object object = it.next(); System.out.println(object); } //3.4使用列表迭代器，和Iterator的区别，ListIterator可以向前或者向后遍历、添加、删除、修改元素 System.out.println("-------3.4使用列表迭代器从前往后------------"); ListIterator lit = list.listIterator(); while(lit.hasNext()){ System.out.println(lit.nextIndex() +":"+lit.next()); } System.out.println("-------3.4使用列表迭代器从前往后------------"); while(lit.hasPrevious()){ System.out.println(lit.previousIndex()+":"+lit.previous()); } //4.判断 System.out.println(list.contains("苹果")); System.out.println(list.isEmpty()); //5.获取位置 System.out.println(list.indexOf("华为")); } } import java.util.ArrayList; import java.util.List; /** * list的使用 * */ public class Demo04 { public static void main(String[] args) { //创建集合 List list = new ArrayList<>(); //1.添加数据 list.add(20); list.add(30); list.add(40); list.add(50); list.add(60); System.out.println("元素个数："+list.size()); System.out.println(list); //2.删除元素 //list.remove(0); /* list.remove(new Integer(20)); System.out.println("删除元素之后，元素个数："+list.size()); System.out.println(list);*/ //3.补充方法subList，返回子集合，含头不含尾 List subList = list.subList(1,3); System.out.println(subList); } }

List实现类

ArrayList【重点】

数组结构实现，查询快、增删慢。JDK1.2版本，运行效率快、线程不安全。

Vector

数组结构实现，运行效率慢、线程安全。JDK1.0版本，运行效率慢、线程安全。

LinkedList：

链表结构实现，增删快、查询慢。

List常见实现类

ArrayList DEFAULT_CAPACITY = 10;：默认容量

​ 注意：如果没有向集合中添加任何元素时，容量为0,添加任意一个元素之后容量为10，每次扩容大小是原来的1.5倍

​ elementData存放数组的元素

​ size 实际元素个数

​ add（）添加元素

ArrayList

数组结构实现，查询快、增删慢。JDK1.2版本，运行效率快、线程不安全。 import java.util.ArrayList; import java.util.Iterator; import java.util.ListIterator; /* * ArrayList的使用 *存储结构：数组，查找遍历速度快，增删慢 * */ public class Demo05 { public static void main(String[] args) { //1.创建集合 ArrayList arrayList = new ArrayList<>(); //2.添加元素 Student s1 = new Student("刘德华",20); Student s2 = new Student("张学友",22); Student s3 = new Student("郭富城",28); arrayList.add(s1); arrayList.add(s2); arrayList.add(s3); System.out.println("元素个数："+arrayList.size()); System.out.println(arrayList); //3.删除元素 /* arrayList.remove(new Student("刘德华",20)); System.out.println("删除之后："+arrayList.size());*/ //4.遍历元素【重点】 //4.1使用迭代器 System.out.println("=======4.1使用迭代器============"); Iterator it = arrayList.iterator(); while(it.hasNext()){ Student s = (Student)it.next(); System.out.println(s); } //使用列表迭代器，和Iterator的区别，ListIterator可以向前或者向后遍历、添加、删除、修改元素 System.out.println("-------4.2使用列表迭代器从前往后------------"); ListIterator lit = arrayList.listIterator(); while(lit.hasNext()){ System.out.println(lit.nextIndex() +":"+lit.next()); } System.out.println("-------4.3使用列表迭代器从前往后------------"); while(lit.hasPrevious()){ System.out.println(lit.previousIndex()+":"+lit.previous()); } //5.判断 System.out.println(arrayList.contains(new Student("刘德华",20))); System.out.println(arrayList.isEmpty()); //6.查找 System.out.println(arrayList.indexOf(new Student("刘德华",20))); } } /* * 学生类 * * */ public class Student { private String name; private int age; public Student() { } public Student(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 "Student{" + "name='" + name + '\'' + ", age=" + age + '}'; } @Override public boolean equals(Object obj) { //1.判断是不是同一个对象 if(this==obj){ return true; } //2.判断是否为空 if(obj==null){ return false; } //3.比较属性 if(obj instanceof Student){ Student s = (Student)obj; //4.比较属性 if(this.name.equals(s.getName())&&this.age==s.getAge()){ return true; } } //5.不满足条件返回false return false; } } public boolean add(E e) { ensureCapacityInternal(size + 1); // Increments modCount!! elementData[size++] = e; return true; } private void ensureCapacityInternal(int minCapacity) { if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity); } ensureExplicitCapacity(minCapacity); } private void ensureExplicitCapacity(int minCapacity) { modCount++; // overflow-conscious code if (minCapacity - elementData.length > 0) grow(minCapacity); }

Vector

数组结构实现，查询快、增删慢；JDK1.0版本，运行效率慢、线程安全。 /* * 演示Vector集合的使用 *存储结构：数组 * */ import java.sql.SQLOutput; import java.util.Enumeration; import java.util.Vector; public class Demo06 { public static void main(String[] args) { //创建集合 Vector<Object> vector = new Vector<>(); //1.添加元素 vector.add("草莓"); vector.add("芒果"); vector.add("西瓜"); System.out.println("元素个数："+vector.size()); System.out.println(vector); //2.删除 /* vector.remove(0); vector.remove("西瓜"); vector.clear(); */ //3.遍历 //使用枚举器 Enumeration en = vector.elements(); while(en.hasMoreElements()){ String o = (String)en.nextElement(); System.out.println(o); } //4.判断 System.out.println(vector.contains("西瓜")); System.out.println(vector.isEmpty()); //5.vector其他方法 //firstElement\lastElement、ElementAt(); } }

LinkedList

链表结构实现，增删快、查询慢。 import java.util.Iterator; import java.util.LinkedList; import java.util.ListIterator; /* *LinkedList 的使用 *存储结构：双向链表 * */ public class Demo07 { public static void main(String[] args) { //创建集合 LinkedList linkedList = new LinkedList(); //1.添加元素 Student s1 = new Student("刘德华",20); Student s2 = new Student("郭富城",22); Student s3 = new Student("郭富城",18); //1.添加元素 linkedList.add(s1); linkedList.add(s2); linkedList.add(s3); System.out.println("元素个数："+linkedList.size()); System.out.println(linkedList); //2.删除元素 /* linkedList.remove(new Student("刘德华",20)); System.out.println("删除之后："+linkedList.size()); linkedList.clear();*/ //3.遍历 //3.1for遍历 System.out.println("======3.1for遍历======="); for (int i = 0; i <linkedList.size() ; i++) { System.out.println(linkedList.get(i)); } //3.2增强for System.out.println("=========3.2增强for==========="); for (Object object:linkedList) { Student s = (Student)object; System.out.println(s); } //3.3使用迭代器 System.out.println("=========3.3使用迭代器==========="); Iterator it = linkedList.iterator(); while(it.hasNext()){ Student s = (Student)it.next(); System.out.println(s); } //3.4使用列表迭代器 System.out.println("=========3.3使用列表迭代器==========="); ListIterator lit = linkedList.listIterator(); while(lit.hasNext()){ Student s = (Student)lit.next(); System.out.println(s); } //4.判断 System.out.println(linkedList.contains(s1)); System.out.println(linkedList.isEmpty()); //5.获取 System.out.println(linkedList.indexOf(s1)); } }

ArrayList和LinkedList的区别：

ArrayList：必须开辟连续空间，查询快、增删慢。

LinkedList：无需开辟连续的空间，查询慢，增删快。