java-Collection集合，List集合

集合数组

65.集合的由来和集合继承体系图

-集合的由来：数组长度是固定,当添加的元素超过了数组的长度时需要对数组重新定义,太麻烦,java内部给我们提供了集合类,能存储任意对象,长度是可以改变的,随着元素的增加而增加,随着元素的减少而减少 

-数组和集合的区别：

   1：

           *数组既可以存储基本数据类型，也可以存储引用数据类型，基本数据类型存储的是值，引用数据类型存储的是地址值

           *集合只能存储引用数据类型（对象）集合中也可以存储基本数据类型，但在存储的时候会自动装箱为对象，100->new Integer(100)

    2:

            *数组的长度是固定的，不能自动增长

            *集合的长度是可变的，可以根据元素的增加而增长

-集合和数组什么时候用：

            *如果元素个数是固定推荐用数组，因为当使用集合时，由于集合也有通过数组实现的，所以在赋值时可能会产生大量垃圾，浪费内存

            *如果元素个数不是固定的推荐用集合

-集合继承体系图：

66.Collection集合的基本功能

-方法：

        boolean add(E e)              //向集合中添加元素（参数为object的任意对象）

注：add方法如果是List集合一直会返回true，因为List集合是可以存储重复元素的，如果是Set集合存储重复元素就会返回false
        boolean remove(Object o)      //删除集合中的元素
        void clear()                               //清空集合中的元素
        boolean contains(Object o)    //查看集合中是否包含指定元素，返回一个boolean值
        boolean isEmpty()                   //判断集合是否为空
        int size()                                    //获取集合中元素的个数

-ArrayList的父类的父类重写toString方法，所以在打印对象引用的时候，输出的结果不是Object类中toString的结果

package Collection;

import java.util.ArrayList;
import java.util.Collection;

public class demo1 {

	public static void main(String[] args) {
		Collection c = new ArrayList();           //父类引用指向子类对象，编译看父类，运行看子类
		
		boolean b1 = c.add("abc");  
		boolean b2 = c.add(true);                 //基本数据类型，会自动装箱，new Boolean(true);
		boolean b3 = c.add(123);                 //new Integer(123)
		boolean b4 = c.add(new Student("张三",23));     
		
		System.out.println(c);
	}

}

67.集合的遍历

-遍历：其实就是依次获取集合中的每一个元素

-实现：将集合转换为数组，可以实现集合的遍历

           方法：toArray();                   //将集合转换为数组

package Collection;

import java.util.ArrayList;
import java.util.Collection;

public class demo2 {

	public static void main(String[] args) {
		demo1();
		Collection c = new ArrayList();
		c.add(new Student("张三",23));         //Object obj = new Student("张三",23);  向上转型 ，多态弊端无法使用子类特有的属性和方法
		c.add(new Student("李四",24));
		c.add(new Student("王五",25));
		c.add(new Student("赵六",26));
		Object[] arr = c.toArray();                  //将集合转换为Object数组
		for (int i = 0; i < arr.length; i++) {
			//System.out.println(arr[i]);        //它的作用只是为了显示
			Student s = (Student)arr[i];          //将obj向下转型为Student对象，这样就可以使用student中特有的属性和方法
			System.out.println(s.getName()+".."+s.getAge());    //这样不仅可以显示，还可以获取数据做其他操作
		}
	}

	private static void demo1() {
		Collection c = new ArrayList();
		c.add("a");
		c.add("b");
		c.add("c");
		c.add("d");
		
		Object[] arr = c.toArray();
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}

}

68.Collection集合中带All的方法测试

-方法：

        boolean addAll(Collection c)                          //将整个集合添加为另一集合的元素中，合并
        boolean removeAll(Collection c)                    //删除的是交集
        boolean containsAll(Collection c)                  //判断一集合是否包含另一集合的元素，可以重复，但如果另一集合含有集合中不存在的元素，则返回fasle
        boolean retainAll(Collection c)                       //获取两个集合的交集，如果调用的集合改变就返回true，如果调用的集合不变就返回false

package Collection;

import java.util.ArrayList;
import java.util.Collection;

public class demo3 {

	public static void main(String[] args) {
		addAll();
		removeAll();
		containsAll();
		Collection c1 = new ArrayList();
		c1.add("a");
		c1.add("b");
		c1.add("c");
		c1.add("d");
		Collection c2 = new ArrayList();
		c2.add("a");
		c2.add("b");
		c2.add("b");
		boolean b = c1.retainAll(c2);
		Collection c3 = new ArrayList();
		c3.add("a");
		c3.add("b");
		c3.add("c");
		c3.add("d");
		c3.add("e");
		c3.add("f");
		System.out.println("获取c1,c2中相同的元素，若c1改变，返回true若不变，返回false");
		System.out.println(b);
		System.out.println(c1);
		System.out.println("c3包含c1的全部元素，此时c1不变，返回false");
		boolean b2 = c1.retainAll(c3);
		System.out.println(b2);
		System.out.println(c1);
	}

	private static void containsAll() {
		Collection c1 = new ArrayList();
		c1.add("a");
		c1.add("b");
		c1.add("c");
		c1.add("d");
		Collection c2 = new ArrayList();
		c2.add("a");
		c2.add("b");
		c2.add("b");
		boolean b = c1.containsAll(c2);
		System.out.println("判断c1中是否含有c2中的所有元素，c2中的元素可以重复，但如果含有c1没有的元素，则返回false");
		System.out.println(b);
		System.out.println(c1);
	}

	private static void removeAll() {
		Collection c1 = new ArrayList();
		c1.add("a");
		c1.add("b");
		c1.add("c");
		c1.add("d");
		Collection c2 = new ArrayList();
		c2.add("a");
		c2.add("b");
		c2.add("3");
		boolean b = c1.removeAll(c2);
		System.out.println("获取两个集合的交集，若没有交集则返回false");
		System.out.println(b);
		System.out.println(c1);
	}

	private static void addAll() {
		Collection c1 = new ArrayList();
		c1.add("a");
		c1.add("b");
		c1.add("c");
		c1.add("d");
		Collection c2 = new ArrayList();
		c2.add("a");
		c2.add("b");
		c2.add("3");
		boolean b = c1.addAll(c2);
		System.out.println("将两个集合合并，并将结果返回给调用的集合");
		System.out.println(b);
		System.out.println(c1);
	}

}

69.集合的遍历之迭代器遍历

-概述： 集合是用来存储元素,存储的元素需要查看,那么就需要迭代(遍历) 

-迭代器：Iterator（接口）

-迭代器原理：迭代器是对集合进行遍历,而每一个集合内部的存储结构都是不同的,所以每一个集合存和取都是不一样,那么就需要在每一个类中定义hasNext()和next()方法,这样做是可以的,但是会让整个集合体系过于臃肿,迭代器是将这样的方法向上抽取出接口,然后在每个类的内部,定义自己迭代方式,这样做的好处有二,第一规定了整个集合体系的遍历方式都是hasNext()和next()方法,第二,代码有底层内部实现,使用者不用管怎么实现的,会用即可 

-方法：

          *boolean hasnext()                    //如果仍有元素可以迭代，返回true

          *next()                                         //返回迭代的下一个元素

         

package Collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class demo4 {

	public static void main(String[] args) {
		demo1();
		Collection c = new ArrayList();
		c.add(new Student("张三",23));         //Object obj = new Student("张三",23);  向上转型 ，多态弊端无法使用子类特有的属性和方法
		c.add(new Student("李四",24));
		c.add(new Student("王五",25));
		c.add(new Student("赵六",26));
		Iterator it = c.iterator();           //获取迭代器
		while(it.hasNext()){
			Student s = (Student)it.next();                  //将集合中的元素向下转型，由object对象转换为Student对象
			System.out.println(s.getName()+".."+s.getAge());
		}
	}

	private static void demo1() {
		Collection c = new ArrayList();
		c.add("a");
		c.add("b");
		c.add("c");
		c.add("d");
		Iterator it = c.iterator();          //获取迭代器
		while(it.hasNext()){
			System.out.println(it.next());           //指针会自动向后移动
 		}
	}

}

70.List集合的特有功能概述

-概述：有序的Collection也称为序列，此接口的用户可以对列表中每个元素的插入位置进行精确的控制，用户可以根据元素的整数索引访问元素，并搜索列表中的元素。

-方法：

    * void add(int index,E element)        //在列表的指定位置插入元素
    * E remove(int index)                        //删除指定位置的元素
    * E get(int index)                               //根据索引获取指定元素
    * E set(int index,E element)             //修改指定位置的元素

package Collection;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class demo5_List {

	public static void main(String[] args) {
		add();
		remove();
		get();
		set();
	}

	private static void set() {
		List list = new ArrayList();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		list.set(1, "x");
		System.out.println(list);
	}

	private static void get() {
		List list = new ArrayList();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		//利用迭代器遍历List集合
		Iterator it = list.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}	
		//通过索引遍历List集合
		for(int i=0;i<list.size();i++){
			System.out.print(list.get(i) +" ");
		}
		System.out.println();
	}

	private static void remove() {
		List list = new ArrayList();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		list.add(111);
		list.add(222);
		Object obj = list.remove(1);               //返回删除的元素，根据索引删除指定元素
		//Object obj1 = list.remove(111);       //参数不能为数字，将数字当成了索引，所以会报错
		System.out.println(obj);
		System.out.println(list);
	}

	private static void add() {
		List list = new ArrayList();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		list.add(4, "e");                    //index<=size    ,且index>=0都不会触发异常
		//list.add(10,"e");               IndexOutOfBoundsException索引越界异常
		System.out.println(list);
	}

}

-List集合的遍历

package Collection;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class demo6 {

	public static void main(String[] args) {
		List list  = new ArrayList();
		list.add(new Student("张三",23));
		list.add(new Student("李四",24));
		list.add(new Student("王五",25));
		list.add(new Student("赵六",26));
		//利用get方法遍历
		for (int i = 0; i < list.size(); i++) {
			//System.out.println(list.get(i));
			Student s = (Student)list.get(i);
			System.out.println(s.getName()+".."+s.getAge());
		}
		System.out.println();
		//利用迭代器遍历
		Iterator it = list.iterator();
		while(it.hasNext()){
			Student s = (Student)it.next();             //将obj对象向下转型，这样就可以使用student类中特有的属性和方法
			System.out.println(s.getName()+".."+s.getAge());
		}
	}

}

-并发修改异常产生的原因及解决方案

-ListIterator接口：系列表迭代器，允许按任一方法遍历集合，迭代期间修改列表，接口中有add方法，可以在迭代期间向列表添加元素，而不触发并发修改异常（ConcurrentModificationException）的错误

package Collection;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class demo7_listIterator {
	public static void main(String[] args){
		List list = new ArrayList();
		list.add("a");
		list.add("b");
		list.add("hello");
		list.add("c");
		list.add("d");
		/*Iterator it= list.iterator();     //获取迭代器
		while (it.hasNext()) {             //判断集合是否有元素
			String s = (String)it.next();      //向下转型
			if("hello".equals(s)){             //如果集合中含有"hello"字符串，就向集合中添加world
				list.add("wolrd");          //遍历的同时再增加元素，不允许在遍历期间修改集合，触发ConcurrentModificationException异常（并发修改异常）
			}
		}*/
		ListIterator lit = list.listIterator();
		while (lit.hasNext()) {             //判断集合是否有元素
			String s = (String)lit.next();      //向下转型
			if("hello".equals(s)){             //如果集合中含有"hello"字符串，就向集合中添加world
				lit.add("wolrd");               //调用	ListIterator接口中的add方法，允许再遍历期间修改集合
			}
		}
		System.out.println(list);
	}
}

-ListIterator接口功能

      * boolean hasNext()         是否有下一个
      * boolean hasPrevious()  是否有前一个
      * Object next()                  返回下一个元素
      * Object previous()           返回上一个元素

71.Vector接口的概述

-概述：实现了List接口，功能被ArrayList取代

-特有功能：

未实现List接口时，Vector通过枚举来遍历获取集合中的值

          *void addElement(obj E)           添加元素

-Enumeration      枚举对象，实现枚举功能

       *hasMoreElements()             测试此枚举是否包含更多的元素

       *nextElement()                      如果还有下一个对象，返回下一个元素

package Collection;

import java.util.Enumeration;
import java.util.Vector;

public class demo8_Vector {

	public static void main(String[] args) {
		Vector v = new Vector();
		v.addElement("a");
		v.addElement("b");
		v.addElement("c");
		v.addElement("d");
		Enumeration en = v.elements();                 //获取枚举
		while(en.hasMoreElements()){                 //判断是否有元素
			System.out.println(en.nextElement());      //输出集合中的所有元素
		}
	}

}

 72.List的三个子类

-数组与链表的比较:
    数组：查询快修改也快

               增加和删除慢

    链表：查询慢修改也慢

               增加和删除快

-ArrayList，LinkList，Vector的比较：

        *ArrayList:
              底层数据结构是数组，查询快，增删慢。
              线程不安全，效率高。
        *Vector:
              底层数据结构是数组，查询快，增删慢。
              线程安全，效率低。
                 *1.Vector相对ArrayList查询慢(线程安全的)
                 *2.Vector相对LinkedList增删慢(数组结构)
        *LinkedList:
              底层数据结构是链表，查询慢，增删快
              线程不安全，效率高
   *Vector和ArrayList的区别：
              Vector是线程安全的,效率低
              ArrayList是线程不安全的,效率高
        共同点:都是数组实现的
    *ArrayList和LinkedList的区别
              ArrayList底层是数组结果,查询和修改快
              LinkedList底层是链表结构的,增和删比较快,查询和修改比较慢
       共同点:都是线程不安全的

73.ArrayList去重

-思路：1.创建新集合接收老集合中不重复的值

            2.获取老集合中的迭代器

            3.遍历老集合

            4.通过新集合是否包含老集合中的元素，如果包含就不添加，不包含就添加

package Collection;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class demo9_ArrayList去重 {

	public static void main(String[] args) {
		ArrayList list = new ArrayList();
		list.add("a");
		list.add("a");
		list.add("a");
		list.add("b");
		list.add("b");
		list.add("b");
		list.add("c");
		list.add("c");
		list.add("b");
		ArrayList li = method(list);
		System.out.println(li);
	}
	public static ArrayList method(ArrayList list){
		ArrayList al = new ArrayList();                     //创建新集合
		Iterator it = list.iterator();                            //获取传入集合的迭代器
		while(it.hasNext()){
			Object obj = it.next();                                //取得集合中每一个元素
			if(!al.contains(obj)){                                  //如果新集合不包含obj，就添加
				al.add(obj);
			}
		}
		return al;
	}
}

-自定义类实现去重

-注意点：Contains方法和remove方法底层是通过equals方法实现的，如果自定义类没有重写equals方法的话，就会调用object类的equals方法，此时比较的是对象的地址值。

package Collection;

import java.util.ArrayList;
import java.util.Iterator;

public class demo9_ArrayLIst2 {

	public static void main(String[] args) {
		ArrayList list = new ArrayList();
		list.add(new Student("张三",23));
		list.add(new Student("张三",23));
		list.add(new Student("张三",25));
		list.add(new Student("李四",24));
		list.add(new Student("李四",24));
		ArrayList al = method(list);
		System.out.println(al);
	}
	public static ArrayList method(ArrayList list){
		ArrayList aList = new ArrayList();                //创建新集合
		Iterator it = list.iterator();
		while(it.hasNext()){
			Object obj = it.next();
			if(!aList.contains(obj)){                            //Contains底层是通过equals实现的，如果自定义类没有重写equals方法，就会自动调用object类的equals方法，此时比较的是地址值
				aList.add(obj);
			}
		}
		return aList;
	}
}


Student类：
@Override           //重写equals方法
	public boolean equals(Object obj) {
		Student s = (Student)obj;
		return this.name.equals(s.name) && this.age == s.age;
	}

75.LinkedList的概述及使用

-概述：List接口的链表形式实现

-链表：查询和修改慢，增加和删除快，因为链表的每一个元素（除开头和结尾外）都保留着它前一个元素和后一个元素的地址，这样就可以以链的形式连接，但查询时，只能从头或从尾依次查找，直至找到，所以查询慢，而删除时只要将两个元素之间的链去掉即可。

-方法：

    * public void addFirst(E e)及addLast(E e)           //在链的头部或尾部添加元素
    * public E getFirst()及getLast()                             //获取链的头部或尾部的元素
    * public E removeFirst()及public E removeLast()       //删除链的头部或尾部的元素
    * public E get(int index)             //获取指定索引的元素，由（index和size/2）比较，判断应从头部还是尾部开始查找

-用LinkedList模拟栈数据结构

package Collection;

import java.util.LinkedList;

public class demo11_stack {
	private LinkedList list = new LinkedList();
	
	public static void main(String[] args) {
		demo11_stack d = new demo11_stack();
		d.inStack("a");
		d.inStack("b");
		d.inStack("c");
		d.inStack("d");
		while(!d.isEmpty()){
			System.out.println(d.outStack());
		}
	}
	public void inStack(Object obj){
		 list.addFirst(obj);
	}
	public Object outStack(){
		return list.removeFirst();
	}
	public boolean isEmpty(){
		return list.isEmpty();
	}
}

77.增强for概述及其使用

-概述：简化数组及Collection集合的遍历（底层用迭代器实现）

-格式：

           for(元素数据类型 变量 : 数组或者Collection集合) {
                  使用变量即可，该变量就是元素
            }

package generic;

import java.util.ArrayList;

public class demo5_foreach {

	public static void main(String[] args) {
		int arr[]  = {11,22,33,44,55};
		for (int i : arr) {
			System.out.println(i);
		}
		ArrayList< String > list = new ArrayList<>();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		for (String string : list) {
			System.out.println(string);
		}
	}

}

78.三种迭代的能否删除

package generic;

import java.util.ArrayList;
import java.util.Iterator;

public class demo6 {

	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<>();
		list.add("a");
		list.add("b");
		list.add("b");
		list.add("c");
		list.add("d");
		//for 循环遍历删除指定元素
		/*for (int i = 0; i < list.size(); i++) {       
			if("b".equals(list.get(i))){            //找到"b"
				list.remove(i--);                          //删除"b"，并使索引回退一位，因为当删除一个元素时，list的size会减少一位，此时如果i的索引不减一的话，就会跳过删去元素的下一位元素
			}*/
		//迭代器循环遍历删除指定元素
		/*Iterator<String> it = list.iterator();
		while (it.hasNext()) {
			if("b".equals(it.next())){
				it.remove();
				//list.remove("b");                不能用集合的修改方法，因为会出现并发修改异常
		}
		}*/
		//foreach循环遍历删除（不可以）因为foreach底层依赖迭代器实现
		/*for (String string : list) {
			if("b".equals(string)){
				list.remove("b");                //并发修改异常，不能删除指定元素
			}
		}*/
	}
}

79.静态导入

-概述：静态导入类方法

-格式：import static 包名... 类名.方法名

            可以直接导入到方法的级别

-注意事项：方法必须是静态的，但如果有多个同名的静态方法，容易不知道使用谁？这个时候要使用，必须加前缀。

80.可变参数

-概述：当定义方法的时候不知道应该定义多少个参数

-格式：

       *修饰符 返回值类型 方法名（数据类型 ... 变量名）{}

-注意事项：

        *这里的可变参数其实是一个数组

        *如果一个方法有可变参数，并且还有多个参数，可变参数肯定是最后一个

package generic;

public class demo7_changeableargs {

	public static void main(String[] args) {
		String[] arr = {"a","b","c","d"};
		method("s1","z","x","y");
	}
	public static void method(String s1,String ... arr1){
		for (String string : arr1) {
			System.out.println(string);
		}
	}
}

81.asList方法

-功能：将数组转换成集合

-注意：

          *数组转换成集合后不能增加或删除元素，但是可以用集合的思想来操作数组，也就是说可以使用其他集合里的方法

          *基本数据类型转数组，会将整个数组转化为一个对象

          *将数组转化为集合，数组必须是引用数据类型

package Arrays;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class demo2_asList {

	public static void main(String[] args) {
		Integer[] arr = {11,11,22,33,33,44,44,55};
		List<Integer> list = Arrays.asList(arr);
		System.out.println(list);               //数组转集合只能是引用数据类型
		listtoarray();
	}

	private static void listtoarray() {
		ArrayList<String> list = new ArrayList<>();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		String[] arr = list.toArray(new String[5]); //当集合转数组时，数组的长度如果<=size，转换后的数组长度等于集合的size，如果>size，那么数组的长度就和你指定的长度一样
		for (String string : arr) {
			System.out.println(string);
		}
	}
}

82.集合中嵌套集合

package Collection;

import java.util.ArrayList;

public class demo12 {

	public static void main(String[] args) {
		ArrayList<ArrayList<Student>> list = new ArrayList<>();
		ArrayList<Student> First = new ArrayList<>();
		First.add(new Student("张三",23));
		First.add(new Student("李四",24));
		First.add(new Student("王五",25));
		ArrayList<Student> Second = new ArrayList<>();
		Second.add(new Student("赵六",26));
		Second.add(new Student("周七",27));
		Second.add(new Student("潘八",28));
		list.add(First);
		list.add(Second);
		for (ArrayList<Student> as :list ) {
			System.out.println(as);
			for (Student s : as) {
				System.out.println(s);
			}
		}
 	}

}