集合知识点一

Arraylist list = new Arratlist();

目的和数组一样，存储数据，底层是Objet的数组

ArrayList    //    底层就是数组，java帮我们封装了
    
ArrayList list = new ArrayList();    //    （）里可以给长度但是没有用
list.size()　　//　　集合长度　　注意：数组.length属性　　String是.length()方法

集合的增加：可以添加重复的数据

集合名.add(    增加内容    );
list.add(111);

//    指定位置添加:
list.add(下标,添加内容);
list.add(2,654);    //不能超出原来集合的最大长度

集合的查找：

集合名.get(    下标    );
list.get(aaaa)
    
查找集合中的某个值
    list.indexof("aaa");
//    .indexof    返回指定数据第一次出现在集合中的下标，没找到返回-1
//    .lastIndexof    返回指定数据最后一次出现在集合中的下标，没找到返回-1
//    .contains    返回一个boolean类型,    查到/没查到。true/false

集合的删除：非int类型

集合名.remove(    删除内容    );
list.remove("aaaa")

集合的删除：针对int，（集合会默认int是下标，必须要使用封装类）

基本数据类型包装的意义：1.String转换 2.创建类型对象

集合名.remove(	int类型的对象	);
list.remove(new Integer(111));

集合的修改：

list.set(下标，添加内容);    //也会越界
list.set(2,5555);

判断集合是否为空

list.isEmpty();    //true为空
list.size();    //0为空

清空集合

list.clear();

类型转换

List<Student> lists = new ArrayList<>(sets);
//把sets当做参数传入，实现转换

< > 泛型

< > 泛型    基本数据类型不是objte 
ArrayList<Student> list = new ArrayList<Student>();

//    父类指向子类对象，2种方式都可以
List<Student> list = new ArrayList<Student>();
List<Student> list = new LinkedList<>();

//基本数据类型的泛型集合，必须使用包装类
List<Integer> list = new LinkedList<>();

集合长度增加原理

new——>长度 == 0　　//　　创建集合时长度为0

增——>长度 == 10　　//　　当在集合增加内容时默认给长度10

判断长度 if 10 - 10 > 0　　//　　每次添加时判断长度，当大于0时，调用grow方法

grow方法 10 = 10 + >>1　　//　　集合长度 = 集合长度 + 长度 >> 1 （10的话就是5）

　　使用copyof方法拷贝复制新数组，copyof( 原数组，15 )

特点：

List接口：

1.都是有序的 (按照添加的顺序获取)

2.都有下标

3.都可以重复

Set接口:

特点：

1.不能重复，如果有重复后面的会覆盖前面重复的

2.没有下标，没有.get方法

3.无序的

Vector vector = new Vector()

ArrayList 和Vector有什么区别

ArrayList的方法和实现基本上和Vector一样，底层都是数组的实现

但是Vector的方法都是线程安全的，ArrayList没有考虑线程安全的问题

ArrayList在一些算法上做了优化，效率更高

Stack stack = new Stack(); 和Vector一样都是线程安全

LinkedList linkedList = new LinkedList();

LinkedList 和 ArrayList的区别：

1.ArrayList底层是数组的实现,LinkedList底层是链表的实现

2.ArrayList查找速度快,但是删除和插入的速度慢

3.LinkedList删除和插入的速度快,但是查询速度较慢

4.LinkedList有自己独有的addFirst，addLast，removeLast，removeFirst的方法

链表：

在java中链表就是自己实现了一个类,在类中记录了前一个和后一个的地址每次查找都需要找到前一个或者后一个才能往前或者往后找到

双向循环链表，里面记录了下一个和上一个的地址

linkedList.First("  ");	//	首
linkedList.Last("  ")	//	尾

Set为什么叫HashSet

底层原理通过hash算法实现

HashSet set = new HashSer();

重写前根据内存生成hash值

object重写后： hash值为—根据内容(属性)hash值拼接。

equals重写：比较内容。

通过重写boject只要他们内容一样 hash值就一样（没重写前object只有指向的对象地址一样hash值才一样，根据内存生成hash值）

重写equals只要他们内容一样就为true（没重写前对比的是引用类型变量指向的对象地址）

3种集合循环

foreach循环

for(Object obj:set){
    syso(obj);    //无序输出
}

迭代器 Iterator （推荐LinkedList，Set）

Iterator it = set.iterator();

while(it.hasNext()){
    Object obj = it.next();
    syso(obj);    //有序输出
}

for循环（推荐ArrayList）

for (int i = 0; i < args.length; i++) {
        //    有序输出
        }

TreeSet

TreeSet<Stdent> treeSet = new TreeSet<Stdent>();    //声明一个TreeSet类型
List<Student> lists = new ArrayList<>(sets);    //转换为List类型
Collections.sort(lists);    //    Comparable接口    java.lang包

要实现有序，加入TreeSet的元素必须实现comparable接口的compareTo方法，通常写在JAVABEAN中。

Comparable：

public class Student implements Comparable<Student>{
    
    public int compareTo(Student o) {
        if(this.id > o.id) {
            return 1;
        }
        else if(this.id < o.id){
            return -1;
        }else {
            return 0;
        }    
    }
        
}

List 要实现排序需要写实现Comparator接口中的compare方法，需要在另外一个类或内部类实现

List<Student> list = new ArrayList<>();    //声明一个List类型

Collections.sort(list, new StudentCompare());    //    Comparator接口    java.util

Comparator：

public class StudentCompare implements Comparator<Student>{

    @Override
    public int compare(Student o1, Student o2) {
        if(o1 ==null || o2 == null) {
            return 0;
        }
        return o1.getId() - o2.getId();
    }

}