====
day11
java学习笔记: 基础知识: day11  对象也可以比较大小、集合、List集合、常见的数据结构、集合的工具类Collections

一、对象也可以比较大小
如果想比较两个对象的大小，可以通过实现Comparable接口，重写compareTo方法。
接口，比较器：java.lang.Comparable
方法：public int compareTo(T o);
调用方法：int i = stu1.compareTo(stu2);//this:stu1; o:stu2
如果大于，用1表示；
如果小于，用-1表示；
如果相等，用0表示。

类声明：
public class Student implements Comparable<Student>{
  @Override
  public int compareTo(Student o){
    if(this.getAge() > o.getAge()){return 1;}//大于
    else if(this.getAge() < o.getAge()){return -1;}//小于
    else{return 0;}//相等
  }
}

二、集合
(一)集合类的体系结构
1. 集合的优点
为什么会出现集合类？方便对多个对象进行操作，就必须把这多个对象进行存储。而想要存储多个对象，就不能是基本的变量，应该是一个容器类型的变量。
在容器类型的变量中，数组的长度是固定的，StringBuilder的结果是一个字符串，都不能满足我们的要求。
而集合类的特点是：长度是可变的。正好可以满足我们的要求。

2.集合类的体系结构：见图片  "集合类的体系结构.png"

(1)单列集合的根接口：Collection
List: 元素可以重复，是有序的。
  A. ArrayList: 数组结构。查询快，增删慢。
  B. LinkedList: 链表结构。查询慢，增删快。
Set: 元素不可重复，是无序的。
  A. HashSet
  B. TreeSet: 帮我们把元素排好序。
  C. LinkedHashSet: 它是一个有序的Set。
(2)双列集合的根接口：Map
HashMap:
TreeMap: 根据key来排序。
Hashtable: 它是线程安全的。

(二)Collection集合的基础知识
1.所在包：java.util.Collection
2.public interface Collection<E> extends Iterable<E>
3.Collection是单列集合的顶层接口。
它表示一组对象，这些对象也称为Collection的元素
JDK不提供此接口的任何直接实现。
创建Collection集合对象采用的是多态的方式。

4.<E>是一种特殊的数据类型，泛型
使用：在出现E的地方使用引用数据类型替换即可，如Collection<String>
import java.util.ArrayList;
Collection<String> c = new ArrayList<>();//JDK7的新特性
Collection<String> c = new ArrayList<String>();//多态形式，推荐
//boolean add(E e);添加元素
c.add("Hello");
c.add("World");

5.输出集合元素System.out.println(c);
ArrayList覆盖override了toString()方法

6.集合中不能存放基本数据类型，如果想放基本数据，就用它对应的包装类
Collection<Integer> coll2 = new ArrayList<>();

(三)Collection的成员方法
1.boolean add(E e);//添加元素
boolean add(int index, E e);//在指定位置添加元素
通过查看源代码，我们知道ArrayList集合的add方法返回值永远都是true。
2.boolean remove(Object o);//根据对象从集合中删除元素
boolean remove(int index);//根据索引从集合中删除元素
3.void clear();//清除集合中的元素
4.boolean contains(Object o);//判断集合中是否存在指定的元素
5.boolean isEmpty();//判断集合是否为空，空true，非空false
6.int size();//集合的长度，也就是集合中的元素个数

(四)Collection集合的遍历
1.没有索引，不能用普通for
2.所在的包：java.util.Iterator
3.Iterator<E> iterator();//返回此Collection的元素上进行迭代的迭代器
Iterator<String> it = c.iterator();//返回的是迭代器接口的实现类的对象
通过集合对象调用iterator()方法，得到迭代器对象。
4.Iterator E next();//返回迭代的下一个对象，获取到下一个元素，并移到下一个，等待
NoSuchElementException:没有这样的元素异常
Iterator boolean hasNext();//如果仍有元素可以迭代，则返回true
while(it.hasNext()){
  String s = it.netxt();
  System.out.println(s);
}

5.代码
import java.util.Collection;
import java.util.ArrayList;
import java.util.Iterator;
Collection<String> c = new ArrayList<String>();//创建集合对象
c.add("小静");//给集合中添加字符串元素
c.add("大熊");
c.add("康夫");
Iterator<String> it = c.iterator();//通过集合对象获取到迭代器对象
while(it.hasNext()){//使用迭代器对象的方法获取数据
  String s = it.next();//在一次循环体中，只能调用一次it.next()
  System.out.println(s);
}

6.迭代器是集合遍历的一种方式，依赖于集合而存在。

(五)集合的使用步骤
1.创建集合对象
2.创建元素对象
3.把元素添加到集合
4.遍历集合
  (1)通过集合对象获取迭代器对象
  (2)通过迭代器对象的hasNext()方法判断是否有元素
  (3)通过迭代器对象的next()方法获取元素，并指向下一个位置

三、List集合
1.所属包名：java.util.List
2.List有索引，可以用普通for循环。（没有索引，就不可以用普通for循环。）
3.List是有序的Collection，也称为序列。
4.List集合的特点：
  (1)有序（存储和取出元素的顺序一致）
  (2)存储的元素可重复

5.代码
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
List<String> list = new ArrayList<String>();
list.add("hello");
//...
Iterator<String> it = list.iterator();
while(it.hasNext()){
  String s = it.next();
  System.out.println(s);
}

6.List集合特有的成员方法（完全是针对索引操作的）
void add(int index, E element);//在指定位置添加元素，后面的元素往后移
E remove(int index);//删除指定位置的元素，返回被删除的元素
E get(int index);//获取指定位置的元素
E set(int index, E element);//修改指定位置的元素，返回被修改的元素

7.List集合的普通for遍历
  (1)迭代器
  (2)普通for循环 int size()
for(int i = 0; i < list.size(); i++){
  System.out.println(list.get(i));
}

8.List列表迭代器的特有功能
ListIterator<E> listIterator();//返回此列表元素的列表迭代器，允许程序员按任意方向遍历列表。正向遍历方式与Iterator相同。
public interface ListIterator<E> extends Iterator<E>;
ListIterator<String> list = list.listIterator();
特有功能：
E previous();//返回列表中的前一个元素
boolean hasPrevious();//如果以逆向遍历列表，列表迭代器有多个元素，则返回true
注意事项：ListIterator可以实现逆向遍历，但是要求先正向遍历，才能逆向遍历。

9.ConcurrentModificationException并发修改异常的原因及解决方案
产生的原因：迭代器依赖于集合而存在，在判断成功后，集合中添加了新元素，而迭代器并不知道，所以就报错了。即迭代器遍历集合中的元素的时候，不要使用集合对象去修改集合中的元素。
解决方案：
  方案一：用列表迭代器时，迭代器遍历的时候，用迭代器修改集合中的元素。元素是跟在刚才迭代的元素后面的。
  方案二：用普通for循环时，集合遍历的时候，可以通过集合对象修改集合中的元素。元素是在最后添加的。（推荐此方案）
方案一的代码：
ListIterator<Student> it = list.listIterator();
while(it.hasNext){
  Student stu = it.next();
  if(stu.equals(stu2)){
    it.add(stu4);//用迭代器添加
  }
}
方案二的代码：
for(int i = 0; i < list.size(); i++){
  Student stu = list.get(i);
  if(stu.equals(stu2)){
    list.add(stu4);//用集合添加
  }
}

10.正向删除时，要调整i，i--
逆向删除时，不用调整i
正向删除的代码：
for(int i = 0; i < list.size(); i++){
  if(list.get(i).equals("5")){
    list.remove(i);
    i--;
  }
}

逆向删除的代码：
for(int i = list.size(); i >= 0; i--){
  if(list.get(i).equals("5")){
    list.remove(i);
  }
}

11.增强for：是for循环的一种
格式：
for(元素的数据类型 变量名:数组名或者Collection集合对象名){
  使用变量名即可，这个变量名代表的就是数组或者Collection集合中的元素
}
例如：
for(int x:arr){
 System.out.println(x);
}
好处：简化了数组和Collection集合的遍历
弊端：目标不能为null
在遍历前，对目标做不为null的判断：
if(list != null){
  for(...:list){...}
}
增强for其实就是用来替代迭代器的。

用哪种循环？只想打印集合时，用增强for；如果有增删集合时，用普通for。

四、常见的数据结构
1.栈：先进后出。例如子弹夹
2.队列：先进先出。例如：排毒买票
3.数组：存储同一个数据类型的多个元素的容器，有索引，方便我们获取元素。特点：查询快，增删慢。

在数组中添加一个元素的步骤：
(1)定义一个新数组，长度是以前的数组的长度+1
(2)遍历以前的数组，得到每一个元素
(3)数前面的：按照以前的索引存储到新数组中。
   数本身：继续存储。
   数后面的：添加那个新元素，然后把索引+1存储到新数组中。

从数组中删除一个元素的步骤：
(1)定义一个新数组，长度是以前的数组的长度-1
(2)遍历以前的数组，得到每一个元素。
   数前面的：按照以前的索引存储到新数组中。
   数本身：不存储。
   数后面的：把索引-1存储到新数组中。

4.链表：由一个链子把多个节点连接起来的数据。
节点：由数据和地址组成。
特点：查询慢，增删快。
获取链表中的元素：从头开始

在链表中插入一个元素的步骤（最好自己画一个图）：
(1)新元素应该也是一个节点
(2)把数本身的下一个元素地址用tmp存储。
(3)把新元素的地址付给数本身的下一个元素地址处
(4)把tmp的值赋给新元素的下一个元素地址处

从链表中删除一个元素的步骤（最好自己画一个图）：
(1)把数本身的下一个元素地址用tmp存储
(2)把tmp的值赋给数本身的前一个元素的下一个元素地址处。

底层数据结构是数组结构，用ArrayList，查询快，增删慢。
底层数据结构是链表结构，用LinkedList，查询慢，增删快。
如果数据查询多，就选ArrayList。
如果数据增删多，就选LinkedList。
不知道时，选ArrayList，因为数据量少。

LinkedList的使用与ArrayList的相似。

五、集合的工具类Collections
所属包：java.util.Collections
ArrayList<Integer> list = new ArrayList<Integer>();
Collections.sort(list);//按正向排序
Collections.reverse(list);//反转
Collections.sort(list, Collections.reverseOrder());//倒序

Collection与Collections的区别：
Collection是单列集合的顶层接口。Collections是集合的工具类。
====