目录

1.什么是集合

2.Collection体系

3.泛型

4.Set集合

5.Map

6.Collections工具类

7.为什么要使用双亲委派机制

8.ClassLoader和forName的区别

9.谈谈ConcurrentHashMap

1.什么是集合

1.1概念

对象的容器,实现了对对象的常用操作。

2.2和数组的区别

(1).数组长度固定,集合长度不固定。
(2).数组可以存储基本类型和引用类型,集合只能存储引用类型

2.Collection体系

2.1Collection父接口

特点:代表一组任意类型的对象,无序、无下标、不能重复。

2.1.1常用方法

(1).添加元素:
collection.add();
(2).删除元素:
collection.remove();
collection.clear();

(3).遍历元素(重点)
1.使用增强for(因为无下标)
for(Object object : collection)
2.使用迭代器

//haNext(); 有没有下一个元素
//next(); 获取下一个元素
//remove(); 删除当前元素
Iterator it = collection.iterator();
while(it.hasNext()){
  String object = (String)it.next(); //强转
  // 可以使用it.remove(); 进行移除元素
  // collection.remove(); 不能用collection其他方法 会报并发修改异常
}

(4).判断方法
判断是否包含某对象:contains();
判空:isEmpty();

2.2List子接口

特点:有序、有下标、元素可重复
创建集合对象 List list = new ArrayList<>( );

2.2.1常用方法

(1).添加元素 list.add( ); (会对基本类型进行自动装箱)
(2).删除元素 可以用索引 list.remove(0);
当删除数字与索引矛盾时 对数字强转list.remove((Object) 10);
list.remove(new Integer(10));
(3).遍历
1.使用for遍历

for(int i = 0; i < lise.size(); i++){
  sout(list.get(i)); 
}

2.使用增强for

for(Object list: collection){ 
}

3.使用迭代器

Iterator it = collection.iterator();
while(it.hasNext()){
  String object = (String)it.next(); //强转
  // 可以使用it.remove(); 进行移除元素
  // collection.remove(); 不能用collection其他方法 会报并发修改异常
}

4.使用列表迭代器 💡(注意和迭代器区别)

ListIterator li = list.listIterator();
while(li.hasNext()){
  System.out.println(li.nextIndex() + ":" + li.next()); //从前往后遍历
}
while(li.hasPrevious()){
  System.out.println(li.previousIndex() + ":" + li.previous()); //从后往前遍历
}

(4).获取 list.indexOf();
(5).返回子集合 sublist(x,y);
返回索引1、2 list subList = list.subList(1,3);

2.3List实现类

(1).ArrayList【重点】
1.数组结构实现,必须要连续空间,查询快、增删慢
2.jdk1.2版本,运行效率块、线程不安全
(2).Vector
1.数组结构实现,查询快、增删慢
2.jdk1.0版本,运行
(3).LinkedList
双向链表结构实现,无需连续空间,增删快,查询慢

2.3.1ArrayList

(1).创建集合 ArrayList arrayList = new ArrayList<>();
(2).添加元素 arrayList.add();
(3).删除元素 arrayList.remove(new Student("name", 10));
这里重写了 equals(this obj) 方法

public boolean equals(Object obj){
  //1 判断是不是同一个对象
  if(this == obj){
    return true;
  }
  //2 判断是否为空
  if(obj == null){
    return false;
  }
  //3 判断是否是Student类型
  if(obj instanceof Student){
    Student == (Student)obj;
    //4 比较属性
    if(this.name.equals(s.getName()) && this.age == s.getAge()){
      return true;
    }
  }
  //5 不满足条件返回false
  return false;
}

(4).遍历元素【重点】
1.使用迭代器

Iterator it = arrayList.iterator();
while(it.hasNext()){
  Student s = (Student)it.next(); //强转
}

2.列表迭代器

ListIterator li = arrayList.listIterator();
while(li.hasNext()){
  Student s = (Student)li.next(); //从前往后遍历
}

while(li.hasPrevious()){
  Student s = (Student)li.previous();//从后往前遍历
}

(5).判断
contains();isEmpty
(6).查找
indexof();
(7)源码分析
DEFAULT_CAPACITY = 10; //默认容量
//注意:如果没有向集合中添加任何元素时,容量0,添加一个后,容量为10
//每次扩容是原来的1.5倍
elementData存放元素的数组
size 实际元素个数

2.4Vector

创建集合 Vector vector = new Vector<>();

增加、删除、判断同上

遍历中枚举器遍历

Enumeration en = vector.elements();
while(en.hasMoreElements()){
  String o = (String)en.nextElement();
  sout(o);
}

2.5LinkList

常用方法与List一致

小结

1.对于处理一列数据项,Java 提供了两个类ArrayList 和LinkedList ,ArrayList 的内部实现是基于内部数组Object[] ,从概念上讲,它更像数组,但LinkedList 的内部实现是基于一组连接的记录,所以,它更像一个链表结构,它们在性能上有很大的差别。
2.在ArrayList 的前面或中间插入数据时,必须将其后的所有数据相应的后移,这样必然要花费较多时间,所以,当你的操作是在一列数据的后面添加数据而不是在前面或中间,并且需要随机地访问其中的元素时,使用ArrayList 会提供比较好的性能;而访问链表中的某个元素时,就必须从链表的一端开始沿着连接方向一个一个元素地去查找,直到找到所需的元素为止,所以,当你的操作是在一列数据的前面或中间添加或删除数据,并且按照顺序访问其中的元素时,就应该使用LinkedList 了。
3.如果在编程中,两种情形交替出现,这时,可以考虑使用List 这样的通用接口,而不用关心具体的实现,在具体的情形下,它的性能由具体的实现来保证。
4.ArrayList 的查询效率比较高,增删动作的效率比较差,适用于查询比较频繁,增删动作较少的元素管理的集合。LinkedList 的查询效率低,但是增删效率很高。适用于增删动作的比较频繁,查询次数较少的元素管理集合。
5.ArrayList ,LinkedList 都是线程不安全的。

3. 泛型

3.1基本介绍

1.本质是参数化类型,把类型作为参数传递
2.常见形式有泛型类、泛型接口、泛型方法
3.语法:T成为类型占位符,表示一种引用类型,可以写多个4逗号隔开
4.好处:1. 提高代码重用性 2. 防止类型转换异常,提高代码安全性

3.2泛型类

// 写一个泛型类
public class MyGeneric<T>{
  //使用泛型T
  //1 创建变量
  T t;
  //2 泛型作为方法的参数
  public void show(T t){
    sout(t);
  }
  //3 泛型作为方法的返回值
  public T getT(){
    return t;
  }
}
// 使用泛型类
public class TestGeneric{
  public static void main(String[] args){
    //使用泛型类创建对象
    // 注意: 1. 泛型只能使用引用类型
    //           2. 不用泛型类型对象之间不能相互赋值
    MyGeneric<String> myGeneric = new MyGeneric<String>();
    myGeneric.t = "hello";
    myGeneric.show("hello world!");
    String string = myGeneric.getT();

    MyGeneric<Integer> myGeneric2 = new MyGeneric<Integer>();
    myGeneric2.t = 100;
    myGeneric2.show(200);
    Integer integer = myGeneric2.getT();

  }
}

3.3泛型接口

语法:接口名
注意:不能泛型静态常量

3.4泛型方法

语法: 返回值类型

public class MyGenericMethod{
  //泛型方法
  public <T> T show(T t){
    sout("泛型方法" + t);
    return t;
  }
}

//调用
MyGenericMethod myGenericMethod = new MyGenericMethod();
myGenericMethod.show("字符串");// 自动类型为字符串
myGenericMethod.show(200);// integer类型
myGenericMethod.show(3.14);// double类型

3.5泛型集合

概念:参数化类型、类型安全的集合,强制集合元素的类型必须一致

特点:
1.编译时即可检查,而非运行时抛出异常
2.访问时,不必类型转换(拆箱)
3.不同泛型之间应用不能相互赋值,泛型不存在多态

4.Set集合

特点:无序、无下标、元素不可重复

方法:全部继承自Collection中的方法

增、删、遍历、判断与collection一致

4.1HashSet

1.存储结构:哈希表(数组+链表+红黑树)

2.存储过程(重复依据)
(1).根据hashCode计算保存的位置,如果位置为空,直接保存,若不为空,进行第二步
(2).再执行equals方法,如果equals为true,则认为是重复,否则形成链表

3.特点:
基于HashCode计算元素存放位置
利用31这个质数,减少散列冲突
31提高执行效率 31 * i = (i << 5) - i 转为移位操作
当存入元素的哈希码相同时,会调用equals进行确认,如果结果为true,则拒绝后者存入
4.新建集合HashSet<String> hashSet = new HashSet<String>();

5.添加元素 hashSet.add( );

6.删除元素 hashSet.remove( );

7.遍历操作

(1). 增强for for( type type : hashSet)

(2). 迭代器 Iterator<String> it = hashSet.iterator( );

8.判断: hashSet.contains( ); hashSet.isEmpty();

4.1TreeSet

1.特点:
(1).基于排列顺序实现元素不重复
(2).实现SortedSet接口,对集合元素自动排序
(3).元素对象的类型必须实现Comparable接口,指定排序规则
(4).通过CompareTo方法确定是否为重复元素
(5).存储结构:红黑树

2.创建集合 TreeSet<String> treeSet = new TreeSet<>();

3.添加元素 treeSet.add();

4.删除元素 treeSet.remove();

5.遍历:1.增强for 2.迭代器

6.判断:treeSet.contains();

7.补充:TreeSet集合的使用

8.Comparator 实现定制比较(比较器)

9.Comparable 可比较的

// 重写compare
@override
public int compare(Person o1, Person o2){
  int n1 = o1.getAge()-o2.getAge();
  int n2 = o1.getName().comareTo(o2.getName());
  return n1 == 0 ? n2 : n1;
}

5.Map

5.1Map接口的特点:

  1. 用于存储任意键值对(key - value)
  2. 键:无序、无下标、不允许重复(唯一)
  3. 值:无序、无下标、允许重复

5.2方法:

  1. V put(K key, V value) 将对象存到集合中,关联键值
  2. Object get(Object key) 根据键获得对应的值
  3. Set 返回所有的Key
  4. Collection values() 返回包含所有值的Collection集合
  5. Set<Map.Entry<K, V>> 键值匹配的Set集合

5.3Map接口的使用

    //创建Map集合
Map<String, String> map = new HashMap<>();
// 1. 添加元素
map.put("cn", "中国");
map.put("uk", "英国");
map.put("cn", "zhongguo"); // 会替换第一个 
// 2. 删除
map.remove("uk");
// 3. 遍历
// 3.1 使用KeySet()
//Set<String> keyset = map.keySet(); // 所有Key的set集合
for(String key : map.keyset){
  sout(key + "---" + map.get(key));
}
// 3.2 使用entrySet()
//Set<Map.Entry<String, String>> entries = map.entrySet();
for(Map.Entry<String, String> entry : map.entries){
  sout(entry.getKey() + "---" + entry.getValue();
}

5.4HashMap

1.存储结构:哈希表(数组+链表+红黑树)

2.使用key可使hashcode和equals作为重复

3.增、删、遍历、判断与上述一致

4.源码分析总结:
(1).HashMap刚创建时,table是null,节省空间,当添加第一个元素时,table容量调整为16
(2).当元素个数大于阈值(16*0.75 = 12)时,会进行扩容,扩容后的大小为原来的两倍,目的是减少调整元素的个数
(3).jdk1.8 当每个链表长度 >8 ,并且数组元素个数 ≥64时,会调整成红黑树,目的是提高效率
(4).jdk1.8 当链表长度 <6 时 调整成链表
(5).jdk1.8 以前,链表时头插入,之后为尾插入

5.5HashTable

线程安全,运行效率慢;不允许null作为key或是value

5.6Properties

hashtable的子类,要求key和value都是string,通常用于配置文件的读取

5.7TreeMap

实现了SortedMap接口(是map的子接口),可以对key自动排序

6.Collections工具类

1.概念:集合工具类,定义了除了存取以外的集合常用方法

2.直接二分查找
int i = Collections.binarySearch(list, x); 成功返回索引

3.其他方法 : copy复制、reverse反转、shuffle打乱

4.补充:

// list转成数组
Integer[] arr = list.toArray(new Integer[10]);
sout(arr.length);
sout(Array.toString(arr));

// 数组转成集合
// 此时为受限集合,不能 添加和删除!
String[] name = {"张三","李四","王五"};
List<String> list2 = Arrays.asList(names);

// 把基本类型数组转为集合时,需要修改为包装类
Integer[] nums = {100, 200, 300, 400, 500};
List<Integer> list3 = Arrays.asList(nums);

7.为什么要使用双亲委派机制?

避免多份同样的字节码重复加载

从反向思考这个问题,如果没有双亲委派模型而是由各个类加载器自行加载的话,如果用户编写了一个java.lang.Object的同名类并放在ClassPath中,多个类加载器都去加载这个类到内存中,系统中将会出现多个不同的Object类,那么类之间的比较结果及类的唯一性将无法保证,而且如果不使用这种双亲委派模型将会给虚拟机的安全带来隐患。所以,要让类对象进行比较有意义,前提是他们要被同一个类加载器加载。

8.ClassLoader和forName的区别

隐式加载:new

显式加载:loadclass forname等

类的装载过程:

1.加载:通过classloader加载class文件字节码,生成class对象

2.链接:校验:检查加载的class的正确性和安全性
准备:为类变量分配存储空间并设置类变量初始值
解析:JVM将常量池的符号引用转换为直接引用
3.初始化:执行类变量赋值和静态代码块
所以,class.forname得到的class式已经完成初始化的
classloader.loadclass得到的class式还没有链接的,只完成了第一步
例子:

public class LoadDifference {
    private String name;
    public static void main(String[] args) throws Exception {
//        ClassLoader cl = Robot.class.getClassLoader(); //没有任何输出
        Class r = Class.forName("Robot");//输出了hello robot

    }
}
public class Robot {
    private String name;
    public void sayHi(String helloSentence){
        System.out.println(helloSentence + " " +name);
    }
    private String throwHello(String tag){
        return "Hello" + tag;
    }
    static {
        System.out.println("hello robot");
    }
}

可见他们的区别

9.谈谈ConcurrentHashMap

  • 底层采用分段的数组+链表实现,线程安全 通过把整个Map分为N个Segment,可以提供相同的线程安全,但是效率提升N倍,默认提升16倍。(读操作不加锁,由于HashEntry的value变量是 volatile的,也能保证读取到最新的值。)
  • Hashtable的synchronized是针对整张Hash表的,即每次锁住整张表让线程独占,ConcurrentHashMap允许多个修改操作并发进行,其关键在于使用了锁分离技术
  • 有些方法需要跨段,比如size()和containsValue(),它们可能需要锁定整个表而而不仅仅是某个段,这需要按顺序锁定所有段,操作完毕后,又按顺序释放所有段的锁
  • 扩容:段内扩容(段内元素超过该段对应Entry数组长度的75%触发扩容,不会对整个Map进行扩容),插入前检测需不需要扩容,有效避免无效扩容

且视他人之疑目如盏盏鬼火,大胆去走自己的夜路。