java之类集（数据结构-多线程)-动态数组重点

java类集（数据结构-多线程)-动态数组–类集都在java.util.*这个包下
–动态数组（当元素个数达到最大值时，动态增加容量）
List接口：
1…ArrayList与Vector，LinkedList的区别

相同点：都实现了List接口，这三个子类在使用时没有任何区别,底层均使用数组实现
ArrayList与Vector区别
不同点：1.出现版本不同
ArrayList JDK1.2 Vector JDK1.0 出现在List,Collection接口之前
2.初始化策略区别
Vector在无参构造执行后将对象数组大小初始化为10
ArrayList采用懒加载策略，在构造方法阶段并不初始化对象数组，在第一次添加元素时才初始化对象数组为10
3.扩容策略
Vector扩容时，新数组大小变为原数组的2倍
ArrayList扩容时，新数组大小变为原数组的1.5倍
4.线程安全性
Vector采用在方法上加锁，（synchronized）线程安全，效率较低
ArrayList 采用异步处理，线程不安全，效率较高
即使要使用线程安全的List,也不用Vector
5.遍历：
Vector支持较老的迭代器Enumeration，ArrayList 不支持

ArrayList 和LinkedList区别
LinkedList底层采用双向链表实现，不存在扩容，ArrayList底层采用数组实现。
LinkedList和ArrayList都采用异步处理方式。

2.ArrayList线程不安全的List集合，是否了解JUC包下的线程安全List(CopyOnWriteArrayList)
Set接口
1.Set集合与Map集合的关系
2.hashCode,equals方法关系
3.Comparable,compartor接口的关系
Map
1.请对比HashMap,Hashtable关系
2.是否了解ConcurrentHashMap以及实现原理
1.java类集的产生-JDK1.2
动态数组：解决数组定长问题

1.2 Collection接口-单个对象保存的最顶层父接口
Collection接口以及其子接口，在每次进行数据操作时只能够对单个对象进行处理
public interface Collection extends Iterable;
Iterable:迭代器接口，是为了遍历集合
Iterator Iterator();取得集合得迭代器，JDK1.5之前直接写在collection接口中

Collection接口中提供的核心方法
add(T t):向类集中添加元素
Iterator()：取得类集得迭代器
Collection接口只定义了存储数据得标准，但是无法区分存储类型，一般不直接使用Collection接口，实际中我们往往使用两个子接口List(允许数据重复)，Set(不允许数据重复)，

List接口（80%会使用）—允许数据重复
在进行单个集合处理时，优先考虑list接口
在list接口中，拓展了两个重要方法（独有）
public E get ( int index):根据索引下标取得数据，
public E set ( int index,E element):根据索引下标更新数据，会返回修改前的数据
还有其他方法，remove(),contains(),判断是否包含元素
List接口有三个重要子类：ArrayList,Vector,LinkedList

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

class Person{
private String name;
private Integer age;
public Person(String name , Integer age) {
this.name = name;
this.age = age;
}
public String getName(){
return name;
}
public void setName(String name){
this.name=name;
}
public Integer getAge(){
return age;
}
public void setAge(Integer age){
this.age=age;
}

@Override
public java.lang.String toString() {
return "name="+name+"age="+age;
}
}

public class Test1 {
public static void main(String[] args) {
List<Person>  list=new ArrayList<>();
list.add(new Person("xiaohong",25));
list.add(new Person("saner",5));
System.out.println(list);
System.out.println(list.contains(new Person("saner",5)));//用的是equals方法，判断地址是否相同，输出是false
System.out.println(list.remove(new Person("saner",5)));
System.out.println(list.size());//结果是2，没删掉，因为equals
}
}

因此List接口要想保存自定义类的对象，该类必须覆写equals()来使用contains(),remove()方法

public boolean equals(Object obj){
if(obj==this){
return true;
}
else if(obj==null){
return false;
}
else if(!(obj instanceof  Person)){
return false;
}
//向下转型还原为Person对象
Person  per=(Person)obj;
return  this.age.equals(per.age)&&this.name.equals(per.name);
}

Set接口
不允许数据重复，且Set接口没有扩充方法
Set接口常用子类
HashSet(无序存储)和TreeSet（有序存储）

import java.util.HashSet;
import java.util.Set;

public class Test2 {
public static void main(String[] args) {
Set<String>  set=new HashSet<>();
set.add("hello");
set.add("world");
System.out.println(set);
}
}

运行结果： [world hello ],HashSet(无序存储),不会出现重复的，值通过哈希放在不同的桶里，按桶的顺序打印

1. HashSet底层使用哈希表+红黑树
2. HashSet允许存放空值(null),无序存储
   TreeSet（有序存储）：Comparable,Comparator
   1.底层使用红黑树
   2.不允许出现空值，有序存储
   3.自定义类要想保存到TreeSet中，要么实现Comparable接口，覆写它的compareTo（）方法，要么向TreeSet传入比较器（Comparator接口）

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;
class Person implements Comparable<Person>{
private String name;
private Integer age;

public Person(String name, Integer age) {
this.name = name;
this.age = age;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public Integer getAge() {
return age;
}

public void setAge(Integer age) {
this.age = age;
}

public int compareTo(Person o) {
if(this.age>o.age){
return 1;
}else if(this.age<o.age){
return -1;
}else {
return this.name.compareTo(o.name);
}

}

@Override
public java.lang.String toString() {
return "name=" + name + "age=" + age;
}
}

public class Test2 {
public static void main(String[] args) {
Set<Person> set = new TreeSet<>();
set.add(new Person("zhangsan", 22));
set.add(new Person("hang", 2));
System.out.println(set);
}
}

运行结果：[name=hangage=2, name=zhangsanage=22]
Comparable接口与Comparator接口区别：
在java中，若想实现自定义类的比较，提供了以下两个接口
java.lang.Comparable接口(内部比较器)–排序接口
若一个类实现了Comparable接口，就意味着该类支持排序
存放该类的conllection或数组，可以直接通过collections.sort()或Arrays.sort进行排序。

实现了Comparable接口的类可以直接存放在TreeSet或TreeMap中

public int compareTo(T o);
返回值三种情况
返回正数：表示当前对象大于目标对象
返回0：表示当前对象等于目标对象
返回负数：表示当前对象小于目标对象

Set是脱了马甲的Map

Comparator(外部排序接口)
若要控制某个自定义类的顺序，而该类本身不支持排序（类本身没有实现Comparable接口），我们可以建立一个该类的“比较器”来进行排序。
比较器实现Comparator接口即可
“比较器”：实现了Comparator接口的类作为比较器，通过该比较器来进行类的排序

int compare(T o1,T o2);
返回值与compareTo返回值完全一样
返回正数：表示o1大于o2
返回0：表示o1等于o2
返回负数：表示o1小于o2

class     AscAgeCompartor implements Comparator<Person>{
@Override    public int compare(Person o1, Person o2) {
return o1.getAge()-o2.getAge();
}
}

class     DescAgeCompartor implements Comparator<Person>{
@Override    public int compare(Person o1, Person o2) {
return o2.getAge()-o1.getAge();
}
}

实现了comparator接口更加灵活

实现了comparator接口进行第三方排序–策略模式，此方法更加灵活，可以轻松改变策略进行第三方的排序算法

comparable与comparator接口的关系

comparable接口是排序接口，若一个类实现了comparable接口，意味着该类支持排序，是一个内部比较器，自己去和别人比comparator接口是比较器接口，类本身不支持排序，专门有若干个第三方的比较器（就是一个类实现了comparator接口）来进行类的排序，是一个外部比较器（策略模式）

关于重复元素的判断

TreeSet与TreeMap依靠comparator接口或comparable接口来区分重复元素

自定义类如果想保存在TreeSet或TreeMap中：1.该类直接实现comparable接口，覆写compareTo方法，

2.实现一个比较器传入TreeSet或TreeMap来进行外部比较

而HashSet与HashMap并不依赖比较接口，此时要想区分自定义元素是否重复，需要同时覆写equals与hashCode方法
首先覆写equals方法来判定两个元素内容是否相等。
覆写原则：
自反性：对于任何非空引用值x,x.equals(x)都返回true
对称性：对于任何非空的x,y,当且仅当x.equals(y)返回true,y.equals(x)也返回true
传递性：对于任何的非空的x,y,z,如果x.equals(y)返回true，y.equals(z),返回true,一定有x.equals(z)返回true
一致性：对于对于任何的非空的x,y,若x,y中属性没有改变，则多次调用x.equals(y)始终返回true或false
非空性：对于任何非空引用x,x.equals(null)一定返回false.

public boolean equals(Object obj) {
//自反性
if(obj==this)
{        return true;    }
//非空性
else if(obj==null){
return false;
}
else if(! (obj instanceof Person))
{        return false;    }
//向下转型变成person
Person per=(Person) obj;
return per.age.equals(this.age)&& per.name.equals(this.name);}