文章目录
1 Java集合框架概述
数组的特点
- 初始化之后，长度就确定了
- 声明地类型，就决定了进行元素初始化时的类型
数组存储方面的弊端
- 初始化之后，长度就不可变了，不利于扩展
- 数组提供的方法 & 属性都相对较少，不便于进行添加、删除、插入等操作，效率不高
- 数组存储的数据是有序的，可以重复的
|-----Collection接口：单列集合，用来存储一个一个的对象
|-----List接口：有序的，重复的数据 “动态数组”
|-----ArrayList、LinkedList、Vector
|-----Set接口：无序的，不可重复的数据 ”高中讲的集合“
|-----HashSet、LinkedHashSet、TreeSet
|=====Map接口：双列集合，用来存储一对(Key-value)一对的数据
|-----HashMap、LinkedHashMap、TreeMap、Hashtable、Properties
2 Collection接口方法
public class CollectionTest {
@Test
public void test1(){
Collection coll = new ArrayList();
//1 add(Object e) 将元素e添加到集合coll中
coll.add("AA");
coll.add("BB");
coll.add("123");
coll.add(new Date());
//2 size() 获取添加的元素的个数
System.out.println(coll.size());
//3 addAll() 将coll1 中的元素添加到集合中
Collection coll1 = new ArrayList();
coll1.add("456");
coll1.add("CC");
coll.addAll(coll1);
System.out.println(coll.size());//6
//4 isEmpty() : 判断集合是否为空
System.out.println(coll.isEmpty());
//5 contains(Object obj):判断当前集合中是否包含obj , 会调用obj所在类的equls()
boolean contains = coll.contains(123);
System.out.println(contains);
System.out.println(coll.contains(new String("Tom")));//true 说明调用的是equls
System.out.println(coll.contains(new Person("Jerry",23)));//需要Person类重写equls
}
}
@Test
public void remove(){
// 3 remove(Objcet obj)
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(43);
coll.add(new Person("Jerry",23));
coll.remove(23);
System.out.println(coll);
//6 remove(Object obj)
coll.remove(new Person("Jerry",23));
// removeAll(Collection coll1):从当前集合中移除coll1 中所有的元素
// coll.removeAll(coll);//差集 自己删除自己 就空了
// System.out.println(coll);
//7 retainAll：求交集,删掉不一样的
// System.out.println(coll.retainAll(coll));
//8 equals(Object obj):一个一个的对象进行比较，有序的
//9 转换成数组 toArray()
System.out.println(coll.toArray());
Object[] objects = coll.toArray();
for(int i = 0 ;i < objects.length;i ++){
System.out.println(objects[i]);
}
//10 hashCode():返回当前对象的hash
System.out.println(coll.hashCode());
3 iterator迭代器接口
3.2 iterator接口的方法
//方式1
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// System.out.println(iterator.next());//NoSuchElementException
//方式二
// for(int i = 0 ;i < coll.size();i++){
// System.out.println(iterator.next());
// }
//方式三 推荐
while (iterator.hasNext()){
System.out.println(iterator.next());
}
//增强for(集合元素的类型：集合对象)
for(Object obj : coll){
System.out.println(obj);
}
4 Collection子接口一：List
- Java的数组用来存储数据的局限性，通常使用List替代接口
- List 元素有序、且可重复，集合中的每个元素都有对应的顺序索引
- 每个元素都有对应的序号
* |-----collection接口：单列集合，用来存储一个一个的对象
* |-----List接口：存储有序的、可重复使用的数据 -> "动态数组"，替换原有数组（1.2）
* |-----ArrayList (List接口的主要实现类)（1.2）线程不安全 底层使用Obj[]存储
* |-----LinkedList（1.2）频繁插入删除操作，效率高 底层使用双向链表存储
* |-----Vector (List接口的古老实现类1.0 )线程安全 底层使用Obj[]存储
4.1 ArrayList
ArrayList常用方法
源码分析：JDK7 & JDK8 稍有不同
* 2.1 jdk 7情况下
* ArrayList list = new ArrayList();//底层创建了长度是10的Object[]数组elementData
* list.add(123);//elementData[0] = new Integer(123);
* ...
* list.add(11);//如果此次的添加导致底层elementData数组容量不够，则扩容。
* 默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中。
*
* 结论：建议开发中使用带参的构造器：ArrayList list = new ArrayList(int capacity)
*
* 2.2 jdk 8中ArrayList的变化：
* ArrayList list = new ArrayList();//底层Object[] elementData初始化为{}.并没有创建长度为10的数组
*
* list.add(123);//第一次调用add()时，底层才创建了长度10的数组，并将数据123添加到elementData[0]
* ...
* 后续的添加和扩容操作与jdk 7 无异。
* 2.3 小结：jdk7中的ArrayList的对象的创建类似于单例的饿汉式，而jdk8中的ArrayList的对象
* 的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。
- void add(int index, Object ele):在index位置插入ele元素
- boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
- Object get(int index):获取指定index位置的元素
- int indexOf(Object obj):返回obj在集合中首次出现的位置
- int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
- Object remove(int index):移除指定index位置的元素，并返回此元素
- Object set(int index, Object ele):设置指定index位置的元素为ele
- List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
//1 add
list.add(0,45);
System.out.println(list);
//2 addAll
List<Integer> list1 = Arrays.asList(1, 2, 3);
list.addAll(list1);
System.out.println(list.size());
//3 get
System.out.println(list.get(3));
//4 indexOf 返回第一次出现的索引位置
int i = list.indexOf(456);
System.out.println(i);
//5 lastindexOf 返回最后一次出现的索引位置
//6 remove(int index):移除指定位置的元素，并返归该元素
System.out.println(list.remove(4));
System.out.println(list);
//7 set
list.set(1,"CC");
//8 sublist(int fromIndex,int endIndex):返回左闭右开的子集合
List list2 = list.subList(2, 5);
System.out.println(list2);
ArrayList遍历方法
// 方式1 ： iterator迭代器
// 方式1 ： iterator迭代器
Iterator iterator = list.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
// 方式2 ：增强for循环
// 方式2 ：增强for循环
for(Object obj : list){
System.out.println(obj);
}
//方式3：普通for循环
//方式3：普通for循环
for(int i = 0; i < list.size();i++){
System.out.println(list.get(i));
}
4.2 LinkedList
* 3. LinkedList的源码分析：
* LinkedList list = new LinkedList(); 内部声明了Node类型的first和last属性，默认值为null
* list.add(123);//将123封装到Node中，创建了Node对象。
*
* 其中，Node定义为：体现了LinkedList的双向链表的说法
* private static class Node<E> {
E item;
Node<E> next;
Node<E> prev;
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
5 Collection子接口二：Set
5.1 HashSet
- Set接口是Collection的子接口，没有提供额外的方法
- 不允许包含相同的元素，会添加失败
- Set 判断两个对象是否相等用的是 equls()
public class SetTest {
/*
* Set ： 存储无序 不可重复
* 1 无序
* ！=随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据Hash值决定
* 2 不可重复
* 保证添加元素按照equals()判断时，若为true 则只能添加一个元素
* */
@Test
public void test(){
HashSet Set = new HashSet();
Set.add("123");
Set.add("456");
Set.add("789");
Set.add("AA");
Set.add("BB");
Set.add("BB");
Set.add(new Person("Jerry",23));
Set.add(new Person("Jerry",23));
System.out.println(Set);
Set add过程
二、添加元素的过程：以HashSet为例：
我们向HashSet中添加元素a,首先调用元素a所在类的hashCode()方法，计算元素a的哈希值，
此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为：索引位置），判断
数组此位置上是否已经有元素：
如果此位置上没有其他元素，则元素a添加成功。 --->情况1
如果此位置上有其他元素b(或以链表形式存在的多个元素），则比较元素a与元素b的hash值：
如果hash值不相同，则元素a添加成功。--->情况2
如果hash值相同，进而需要调用元素a所在类的equals()方法：
equals()返回true,元素a添加失败
equals()返回false,则元素a添加成功。--->情况2
对于添加成功的情况2和情况3而言：元素a 与已经存在指定索引位置上数据以链表的方式存储。
jdk 7 :元素a放到数组中，指向原来的元素。
jdk 8 :原来的元素在数组中，指向元素a
总结：七上八下
HashSet底层：数组+链表的结构。
5.2 LinkedHashSet
LinkedHashSet是HashSet的子类
根据元素hashCode值来决定元素的存储位置，同时使用双向链表维护元素的顺序
5.3 TreeSet
//举例二：添加Person 需要Person实现compareable接口
TreeSet Set2 = new TreeSet();
Set2.add(new Person("Jerry",23));
Set2.add(new Person("Jerry",24));
System.out.println(Set2);
//Person cannot be cast to java.lang.Comparable
6 Map接口
* 一、Map的实现类的结构：
* |----Map:双列数据，存储key-value对的数据 ---类似于高中的函数：y = f(x)
* |----HashMap:作为Map的主要实现类；线程不安全的，效率高；存储null的key和value
* |----LinkedHashMap:保证在遍历map元素时，可以按照添加的顺序实现遍历。
* 原因：在原有的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素。
* 对于频繁的遍历操作，此类执行效率高于HashMap。
* |----TreeMap:保证按照添加的key-value对进行排序，实现排序遍历。此时考虑key的自然排序或定制排序
* 底层使用红黑树
* |----Hashtable:作为古老的实现类；线程安全的，效率低；不能存储null的key和value
* |----Properties:常用来处理配置文件。key和value都是String类型
*
*
* HashMap的底层：数组+链表 （jdk7及之前）
* 数组+链表+红黑树 （jdk 8）
Map结构的理解
- Map中的key：无序的、不可重复，使用Set来存储所有key—>key所在的类要重写equals() hashcode()
- Map中的value：无序的、不可重复的，使用Collection存储所有的value —>value所在的类要重写equals()
- 一个键值对：kv 构成了一个Entry对象
- Mao中的entry ： 无序的、不可重复的，使用Set存储所有的entry
HashMap底层实现原理7.0
- new HashMap():实例化之后，底层创建了长度16的一维数组Entry[] table
- map.put(k,v) : 计算hash值，得到放在entry中的位置
+ 如果位置为空，kv添加成功
+ 不为空，(链表存储) ，进行hash值判断
+ hash值不同，kv添加成功
+ hash值相同，用 新的替换旧的 (旧的删除)
扩容机制：扩容为二倍
JDK8.0的不同点
- new HashMap()：底层并没有创建一个长度为16的数组
- jdk 8 底层的数组为Node[] 而不是Entry[]
- 首次调用put发方法时，创建16的数组
- jdk 7 底层 数组 + 链表 。jdk 8 底层 ：数组 + 链表 + 红黑树
+ 形成链表时，七上八下(7.0 指向新元素指向旧元素，8.0旧元素指向新元素)
+ 当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度 > 64时，此时此索引位置上的所数据改为使用红黑树存储。
* DEFAULT_INITIAL_CAPACITY : HashMap的默认容量，16
* DEFAULT_LOAD_FACTOR：HashMap的默认加载因子：0.75
* threshold：扩容的临界值，=容量*填充因子：16 * 0.75 => 12
* TREEIFY_THRESHOLD：Bucket中链表长度大于该默认值，转化为红黑树:8
* MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量:64
添加、删除、修改操作：
Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
void putAll(Map m):将m中的所有key-value对存放到当前map中
Object remove(Object key)：移除指定key的key-value对，并返回value
void clear()：清空当前map中的所有数据
元素查询的操作：
Object get(Object key)：获取指定key对应的value
boolean containsKey(Object key)：是否包含指定的key
boolean containsValue(Object value)：是否包含指定的value
int size()：返回map中key-value对的个数
boolean isEmpty()：判断当前map是否为空
boolean equals(Object obj)：判断当前map和参数对象obj是否相等
元视图操作的方法：
Set keySet()：返回所有key构成的Set集合
Collection values()：返回所有value构成的Collection集合
Set entrySet()：返回所有key-value对构成的Set集合
*总结：常用方法：
* 添加：put(Object key,Object value)
* 删除：remove(Object key)
* 修改：put(Object key,Object value)
* 查询：get(Object key)
* 长度：size()
* 遍历：keySet() / values() / entrySet()
*
/*
元视图操作的方法：
Set keySet()：返回所有key构成的Set集合
Collection values()：返回所有value构成的Collection集合
Set entrySet()：返回所有key-value对构成的Set集合
*/
@Test
public void test5(){
Map map = new HashMap();
map.put("AA",123);
map.put(45,1234);
map.put("BB",56);
//遍历所有的key集：keySet()
Set set = map.keySet();
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println();
//遍历所有的value集：values()
Collection values = map.values();
for(Object obj : values){
System.out.println(obj);
}
System.out.println();
//遍历所有的key-value
//方式一：entrySet()
Set entrySet = map.entrySet();
Iterator iterator1 = entrySet.iterator();
while (iterator1.hasNext()){
Object obj = iterator1.next();
//entrySet集合中的元素都是entry
Map.Entry entry = (Map.Entry) obj;
System.out.println(entry.getKey() + "---->" + entry.getValue());
}
System.out.println();
//方式二：
Set keySet = map.keySet();
Iterator iterator2 = keySet.iterator();
while(iterator2.hasNext()){
Object key = iterator2.next();
Object value = map.get(key);
System.out.println(key + "=====" + value);
}
}
6.3 TreeMap
//向TreeMap中添加key-value，要求key必须是由同一个类创建的对象
//因为要按照key进行排序：自然排序 、定制排序
public class TreeMapTest {
//向TreeMap中添加key-value，要求key必须是由同一个类创建的对象
//因为要按照key进行排序：自然排序 、定制排序
//自然排序
@Test
public void test1(){
TreeMap map = new TreeMap();
User u1 = new User("Tom",23);
User u2 = new User("Jerry",32);
User u3 = new User("Jack",20);
User u4 = new User("Rose",18);
map.put(u1,98);
map.put(u2,89);
map.put(u3,76);
map.put(u4,100);
Set entrySet = map.entrySet();
Iterator iterator1 = entrySet.iterator();
while (iterator1.hasNext()){
Object obj = iterator1.next();
Map.Entry entry = (Map.Entry) obj;
System.out.println(entry.getKey() + "---->" + entry.getValue());
}
}
//定制排序
@Test
public void test2(){
TreeMap map = new TreeMap(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if(o1 instanceof User && o2 instanceof User){
User u1 = (User)o1;
User u2 = (User)o2;
return Integer.compare(u1.getAge(),u2.getAge());
}
throw new RuntimeException("输入的类型不匹配！");
}
});
User u1 = new User("Tom",23);
User u2 = new User("Jerry",32);
User u3 = new User("Jack",20);
User u4 = new User("Rose",18);
map.put(u1,98);
map.put(u2,89);
map.put(u3,76);
map.put(u4,100);
Set entrySet = map.entrySet();
Iterator iterator1 = entrySet.iterator();
while (iterator1.hasNext()){
Object obj = iterator1.next();
Map.Entry entry = (Map.Entry) obj;
System.out.println(entry.getKey() + "---->" + entry.getValue());
}
}
}
6.4 Hashtable
Hashtable是个古老的 Map 实现类，JDK1.0就提供了。不同于HashMap，
Hashtable是线程安全的。
Hashtable实现原理和HashMap相同，功能相同。底层都使用哈希表结构，查询
速度快，很多情况下可以互用。
与HashMap不同，Hashtable 不允许使用 null 作为 key 和 value
与HashMap一样，Hashtable 也不能保证其中 Key-Value 对的顺序
Hashtable判断两个key相等、两个value相等的标准，与HashMap一致。
6.5 Properties
Properties 类是 Hashtable 的子类，该对象用于处理属性文件
由于属性文件里的 key、value 都是字符串类型，所以 Properties 里的 key
和 value 都是字符串类型
存取数据时，建议使用setProperty(String key,String value)方法和
getProperty(String key)方法
Properties pros = new Properties();
FileInputStream fis = new FileInputStream("jdbc.properties");
pros.load(fis);
String name = pros.getProperty("name");
String password = pros.getProperty("password");
System.out.println(name +":"+ password);
fis.close();
7 Collections工具类
Collections 类中提供了多个 synchronizedXxx() 方法，该方法可使将指定集
合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全
问题
199
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
