12_集合框架

集合的概念

有提到：Arrays.asList()的集合不能add()和remove()问题

集合可以理解为存放数据的一个容器，本质上也是一个引用类型的变量。
    
集合与数组做对比
数组:用来存储一组数据类型相同的数据，数据类型可以是基本数据类型，引用类型(固定长度)
集合:一般配合泛型使用，也是存储一组数据类型相同的数据，数据类型只能是引用类型 (可变长度)
理解成动态数组。    
集合与数组并不是等价的(集合的底层结构，有数组，链表，哈希表，红黑树)    

集合的继承体系图解

List

List：有序，可重复集合
常用的实现类:
ArrayList/Vector：数组结构(查询修改效率高，插入，删除效率较低)
LinkedList :链表(查询修改效率较低，插入，删除效率较高)

ArrayList的应用

public static void main(String[] args) {
		ArrayList<String> list=new ArrayList<>();
		//1.往集合容器中顺序添加元素
		list.add("charles");
		list.add("jack");
		list.add("rouse");
		list.add("marry");
		list.add("iis");
		//2.往指定索引位置插入元素
		list.add(0,"刘德华");
		list.add(2,"王祖贤");
		//list.add(10,"周星驰");//越界手动抛出了,throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
		//3.根据指定索引位置修改元素
		list.set(0,"周润发");
		
		//4.根据指定索引位置删除元素
		list.remove(0);
		
		//4.根据元素删除内容
		list.remove("jack");
		
		//5.遍历集合一（简单for循环 根据索引取出集合中的数据）
		for(int i=0;i<list.size();i++) {
			System.out.println(list.get(i));
		}
		System.out.println("------------------增强for循环------------------");
		//6.使用增强for循环遍历集合容器 ，如果不需要用到索引值.
		for(String str:list) {
			System.out.println(str);
		}
		System.out.println("-------------------迭代器----------------------");
		//7.使用迭代器遍历集合容器
		Iterator<String> it=list.iterator();
		/*System.out.println("第一个元素:"+it.next());
		System.out.println("第二个元素:"+it.next());
		System.out.println("第三个元素:"+it.next());
		System.out.println("第四个元素:"+it.next());
		System.out.println(it.hasNext());//size==cursor 是否取完了集合中的元素 取完了false  没取完true
		System.out.println("第五个元素:"+it.next());*/
		
		/*while(it.hasNext()) {//判断有没有取完集合中的元素，取完了 返回false 
			String ele=it.next();//cursor++
			//System.out.println(it.next());//cursor++ 如果是奇数次，会报异常NoSuchElementException
			System.out.println(ele);
		}*/
		
		/*while (it.hasNext()) {//cursor=size
			it.remove();
		}*/
		/*it.next();//cursor=1  lastRet=0
		it.remove();//第一个元素  cursor=0  lastRet=-1*/		
		
		while(it.hasNext()) {
			String name=it.next();
			if("rouse".equals(name)||"marry".equals(name)){
				it.remove();
			}
		}
		
		//输出内容
		System.out.println(list);
		
		//1.扩展方法 addAll(Collection<? extends E> )
		ArrayList<String> list1=new ArrayList<>();
		list1.add("jj");
		list1.add("kk");
		list.addAll(list1);
		System.out.println(list);
		
		//2.扩展方法toArray();将集合转成数组
		Object[] arr=list.toArray();
		System.out.println(Arrays.toString(arr));
		
		//3.数值类型的删除操作....
		List<Integer> listNum=new ArrayList<>();
		listNum.add(1);
		listNum.add(0);
		listNum.add(3);
		listNum.add(2);
		System.out.println(listNum);
		//4.关于数值类型的删除
		listNum.remove(0);//根据下标删除
		Object obj=0;//根据元素删除怎么办?
		listNum.remove(obj);
		System.out.println(listNum);
	}

问题将数组转成集合Arrays.asList(1,0,3,2,5,4)

    	不能调用add()和remove()方法，点击源码查看
        public static <T> List<T> asList(T... a) {
        	return new ArrayList<>(a);
    	}
    
    	asList方法的实现，但是我们要注意，此ArrayList非我们认识的那个ArrayList，
        而是Arrays类中的一个内部类,查看源码就可看见。
         private static class ArrayList<E> extends AbstractList<E>
        implements RandomAccess, java.io.Serializable
    	{
        	private static final long serialVersionUID = -2764017481108945198L;
        	private final E[] a;

        ArrayList(E[] array) {
            a = Objects.requireNonNull(array);
        }

        @Override
        public int size() {
            return a.length;
        }

        @Override
        public Object[] toArray() {
            return a.clone();
        }

        @Override
        @SuppressWarnings("unchecked")
        public <T> T[] toArray(T[] a) {
            int size = size();
            if (a.length < size)
                return Arrays.copyOf(this.a, size,
                                     (Class<? extends T[]>) a.getClass());
            System.arraycopy(this.a, 0, a, 0, size);
            if (a.length > size)
                a[size] = null;
            return a;
        }

        @Override
        public E get(int index) {
            return a[index];
        }

        @Override
        public E set(int index, E element) {
            E oldValue = a[index];
            a[index] = element;
            return oldValue;
        }

        @Override
        public int indexOf(Object o) {
            E[] a = this.a;
            if (o == null) {
                for (int i = 0; i < a.length; i++)
                    if (a[i] == null)
                        return i;
            } else {
                for (int i = 0; i < a.length; i++)
                    if (o.equals(a[i]))
                        return i;
            }
            return -1;
        }

        @Override
        public boolean contains(Object o) {
            return indexOf(o) != -1;
        }

        @Override
        public Spliterator<E> spliterator() {
            return Spliterators.spliterator(a, Spliterator.ORDERED);
        }

        @Override
        public void forEach(Consumer<? super E> action) {
            Objects.requireNonNull(action);
            for (E e : a) {
                action.accept(e);
            }
        }

        @Override
        public void replaceAll(UnaryOperator<E> operator) {
            Objects.requireNonNull(operator);
            E[] a = this.a;
            for (int i = 0; i < a.length; i++) {
                a[i] = operator.apply(a[i]);
            }
        }

        @Override
        public void sort(Comparator<? super E> c) {
            Arrays.sort(a, c);
        	}
    	}
    	
    	它压根没实现父类的add()和remove()方法,用的是父类AbstractList的默认实现。那我们再看父类的默认实现是啥，请看代码。
    	public boolean add(E e) {
        	add(size(), e);
        	return true;
		}

		public void add(int index, E element) {
        	throw new UnsupportedOperationException();
		}

LinkedList应用

public static void main(String[] args) {
		LinkedList<String> list=new LinkedList<>();
		//1.逐后添加元素
		list.add("zs");
		list.add("ls");
		list.add("ww");
		list.add("zl");
		
		//2.根据索引位置插入数据
		list.add(2,"张三");
		
		//3.根据指定的索引位置修改元素
		list.set(2,"张无忌");
		
		//4.根据索引值删除元素
		list.remove(2);
		
		//5.根据元素的值删除元素
		list.remove("ww");
		
		//链表独有的方法
		//1.插入首元素
		list.addFirst("张无忌");
		list.addFirst("张翠山");
		list.addFirst("张三丰");
		
		//2.插入末尾元素
		list.addLast("孙悟空");
		list.addLast("猪悟能");
		
		//3.删除首元素
		list.removeFirst();
		//4.删除末尾元素
		list.removeLast();
		
		//5.获取首元素
		System.out.println(list.getFirst());
		//6.获取末尾元素
		System.out.println(list.getLast());
		System.out.println(list);
		
		//7.遍历元素一
		for(int i=0;i<list.size();i++) {
			System.out.println(list.get(i));
		}
		//8.遍历元素二
		for(String str:list) {
			System.out.println(str);
		}
		//9.迭代器
		Iterator<String> it=list.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
	}

集合工具类Collections

public static void main(String[] args) {
		List<Integer> list=new ArrayList<Integer>();
		list.add(200);
		list.add(100);
		list.add(500);
		list.add(300);
		list.add(400);
		System.out.println("未排序之前:"+list);
		//1.反转
		Collections.reverse(list);
		System.out.println("反转之后:"+list);
		//2.交换顺序  将最后一个元素与第一个元素交换顺序。
		Collections.swap(list,0, list.size()-1);
		System.out.println("交换顺序之后:"+list);
		//3.随机打乱集合中的顺序
		Collections.shuffle(list);
		System.out.println("随机打乱集合中的顺序:"+list);
		//4.最大值 与最小值
		System.out.println("最高分:"+Collections.max(list));
		System.out.println("最低分:"+Collections.min(list));
		//5.排序
		Collections.sort(list);
		System.out.println("排序之后:"+list);
	}
   

比较器

引入：
但是如果集合中存入的数据为自定义类型比如Student，Teacher，Student(name,age)
    name="jack" age=18;
	？
    name="rouse" age=20;
  默认情况下自定义的类型是无法比较大小的，所以如果集合中保存的是自定义的对象类型，则无法进行排序，甚至无法得到最大值，以及最小值
      ArrayList<Student> list=new ....
      Collections.sort(list)?//不可以
      Collections.max(list)?//不可以
      Collections.min(list)?//不可以
  如果想要进行排序，那么必须使用比较器。 
  
比较的作用:可以通过比较器去自定义对象比较的规则(谁大谁小自己定义)，只要加了比较器的自定义类，才可以使用集合工具类中的sort()排序方法，以及最大值，最小值的方法。
    
Comparable:自比较 
public class Student implements Comparable<Student>{
	private int age;
	private String name;
	private int score;
	
	public Student() {
		super();
	}
	public Student(int age, String name, int score) {
		super();
		this.age = age;
		this.name = name;
		this.score = score;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getScore() {
		return score;
	}
	public void setScore(int score) {
		this.score = score;
	}
	@Override
	public String toString() {
		return "Student [age=" + age + ", name=" + name + ", score=" + score + "]";
	}
	//1.按照成绩进行顺序排列
	//2.如果成绩一样按照年龄进行倒序排列
	@Override
	public int compareTo(Student stu) {
		if(this.getScore()==stu.getScore()) {
			return stu.getAge()-this.getAge();
		}
		return this.getScore()-stu.getScore();
	}
    
	//1.先按照成绩进行顺序排列
	//2.如果成绩一样按照名字进行顺序排序
	@Override
	public int compareTo(Student stu) {
		if(stu.getScore()==this.getScore()) {
			//str1.compareTo(str2); str1>str2  1   str1==str2 0  str1<str2  -1
			return this.getName().compareTo(stu.getName());
		}
		return this.getScore()-stu.getScore();
	}

}

Comparator:类比较
    public static void main(String[] args) {
		List<Student> list=new ArrayList<>();
		list.add(new Student(18,"jack1",87));
		list.add(new Student(20,"jack2",57));
		list.add(new Student(17,"jack3",97));
		list.add(new Student(18,"jack4",67));
		list.add(new Student(16,"jack5",87));
		System.out.println("排序之前:"+list);
		Collections.sort(list,new Comparator<Student>() {
			@Override
			public int compare(Student o1, Student o2) {
                //升序
				return o1.getScore()-o2.getScore();
			}
			
		});
		System.out.println("排序之后:"+list);
		//1.获取的是最后一个元素(顺序排才能拿到最大值)
		Student stu1=Collections.max(list,new Comparator<Student>() {
			@Override
			public int compare(Student o1, Student o2) {
				return o1.getScore()-o2.getScore();
			}
		});
		//2.获取的是第一个元素(顺序排完之后)
		Student stu2=Collections.min(list,new Comparator<Student>() {
			@Override
			public int compare(Student o1, Student o2) {
				return o1.getScore()-o2.getScore();
			}
		});
		System.out.println("最高分的学生信息:"+stu1);
		System.out.println("最低分的学生信息:"+stu2);
	}