java.util.Collection
Collection:
java.util.Collection:
- 1、一个一个的数据;
- 2、常用子接口:
- (1)List: 存储有序的可重复的数据;
-
①具体实现类:ArrayList
- Add AddAll
-
- (1)List: 存储有序的可重复的数据;
java
public static void main(String[] args) {
/* Add AddAll*/
Collection arr = new ArrayList();
arr.add(1); //自动装箱;
arr.add("asd");
arr.add(true);
arr.add(new Object());
arr.add(new Q());
System.out.println(arr);
Collection arr2 = new ArrayList();
arr2.addAll(arr);
System.out.println(arr2);
System.out.println(arr.isEmpty());
System.out.println(arr.size());
System.out.println(arr.contains(1));
System.out.println(arr.contains(new Q())); //false;
Collection arr2 = new ArrayList();
System.out.println(arr.containsAll(arr2)); //是否包含arr2中的所有元素;
}
- remove clear
java
// remove clear
public void test2(){
Collection arr = new ArrayList();
arr.add(1);
arr.clear();
System.out.println(arr);
arr.add(1);
arr.add(1);
arr.add("sad");
System.out.println(arr); //[1,1,sad]
arr.remove(1);
System.out.println(arr); //[1,sad]
Collection arr2 = new ArrayList();
arr.removeAll(arr2);
}
- toArray/ hashcode 、retainAll
java
public void test3(){
/* toArray/ hashcode 、retainAll */
Collection arr = new ArrayList();
Collection arr2 = new ArrayList();
arr.add(1);
arr.add(2);
System.out.println(arr.toArray());
System.out.println(Arrays.toString(arr.toArray()));
arr.retainAll(arr2); //交集
System.out.println(arr.hashCode());
}
- 集合与数组相互装换
java
@Test
public void test4(){
/* Arrays.asList */
List<int[]> list = Arrays.asList(new int[]{1, 2});
Collection arr = Arrays.asList(new String[]{""});
/* toArray */
arr.toArray();
}
- Iterator 迭代器,遍历集合元素
java
@Test
public void test5(){
/**/
Collection arr = new ArrayList();
arr.add(1);
arr.add("asdf");
Iterator iterator = arr.iterator();
//、、方式1
// System.out.println(iterator.getClass());
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// System.out.println(iterator.hasNext());
// System.out.println(iterator.next());
/*遍历*/
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
- 5.0新特性,增强for循环
java
@Test
public void test6(){
/*可以遍历集合等*/
Collection arr = new ArrayList();
arr.add(1);
arr.add("a");
arr.add(true);
for(Object obj: arr){
System.out.println(obj);
}
/*可以遍历数组*/
String[] arr2 = new String[]{"1","2"};
for(String str: arr2){
System.out.println(str);
}
/*底层调用的iterator;断点调试可见*/
}
}
- (2)Set: 无序的,不可重复的;
- ①具体实现类:xxx
Map:java.util.Map
- 1、一对对的数据;(键值对)
- 2、具体实现类:HashMap 等;
java
public void test(){
HashMap map = new HashMap();
/* 增加 */
map.put(null, null);
System.out.println(map);
Map map2 = new HashMap();
map2.put("name", "zhangsan");
/* 修改 */
map2.put("name", "lisi");
System.out.println(map2);
/* 删除(有返回值) */
map.remove(null);
/* 移除不存在的值,无问题 */
map.remove(null);
System.out.println(map);
}
java
@Test
public void test2(){
Map map = new Hashtable();
// map.put("key", null); //空指针;
}
@Test
public void test3(){
LinkedHashMap map = new LinkedHashMap();
map.put("name","name");
map.put("age","12");
System.out.println(map);
/* 查 */
System.out.println(map.get("age"));
}
java
@Test
public void test4(){
Map map = new HashMap();
map.put("name", "zhangsan");
map.put("age", "12");
map.put("gender", "0");
map.put(new Object(), 1);
map.put(1, 1);
System.out.println(map);
Object value = map.get("age"); //
Object value2 = map.get(1); // 装箱;
/* 遍历key */
Set keySet = map.keySet();
Iterator iterator = keySet.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println("============");
/* 遍历value */
Collection values = map.values();
for(Object item: values){
System.out.println(item);
}
}
- 强制类型转换、 entrySet
java
public void test5(){
/* entrySet */
Map map = new HashMap();
map.put("name", "zhangsan");
map.put("age", "12");
map.put("gender", "0");
map.put(new Object(), 1);
map.put(1, 1);
Set entrySet = map.entrySet();
Iterator iterator = entrySet.iterator();
while (iterator.hasNext()){
// Object next = iterator.next();
/* 强制类型转换 */
Map.Entry entry = (Map.Entry) iterator.next();
System.out.println(entry.getKey() + "===>" + entry.getValue());
}
}
List :
- 1、可以替换数组:
- 2、长度是可变的;
- 3、主要的实现类: ArrayList;
java
package com.healthy.collection.collection_20230804;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* @Date 2023/8/4 16:03
* @Discrition
*/
public class ListTest {
@Test
public void test1(){
List list = new ArrayList();
List list2 = new ArrayList();
list2.add(10);
list.add(1);
list.add("2");
list.add(true);
Object obj = new Object();
list.add(obj);
/*插入*/
list.add(2, false); //插入到index之前;
list.addAll(3, list2); //插入到index之前;
System.out.println(list.toString()); //还是基于迭代器的tostring
list.remove(2); //移除index;
// list.remove(String.valueOf(2)); //- -/
// list.remove("2"); //- -/
System.out.println(list);
}
@Test
public void test2(){
List list = new ArrayList();
list.add(5);
list.add(8);
list.add(7);
list.add(6);
System.out.println(list);
/* remove的多态 */
// list.remove((Integer) 8);
// list.remove(new Integer(8));
list.remove(Integer.valueOf(8));
System.out.println(list);
/*循环*/
/*迭代器*/
Iterator iterator = list.iterator();
// while (iterator.hasNext()) {
// System.out.println(iterator.next());
// }
/* 加强for循环 */
// for(Object obj: list){
// System.out.println(obj); //Integer 包装类;
// }
/* 因为index而加 */
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
@Test
public void test3(){
List list = new ArrayList();
list.add(1);
list.add(2);
list.add(3);
Object obj = list.get(1);
list.set(1,list.get(2));
list.set(2, obj);
System.out.println(list);
}
}
List 中的常用方法见代码:ListTest;
实现类的区别;
-
ArrayList:
- 主要实现类;(线程不安全=》效率高)
- 1、查找效率高,增删效率低;
-
Vector:
- 古老实现类:(线程安全=》效率低)
- 1、即使有线程安全问题,也不用这个;
两个底层都是Object[] 数组存储;
LinkedList:
- 1、底层使用双向链表的方式存储;
- 2、双向链表:上知下,下知道上;
- 3、频繁删除、插入推荐此类;
- 4、增删效率高,查找效率低;
Set:
- 1、主要实现类: hashSet;
- 2、接口Set中的常用方法和Collection一致,
- 3、也是用来过滤重复数据的;
- 4、会过滤重复数据;(使用的hash算法)
- 5、Hash算法导致的无序性;
java
@Test
public void test1(){
Set set = new HashSet();
set.add(1);
set.add(2);
set.add("3");
set.add(true);
set.add(new Object());
set.add(new Object());
set.add(3);
set.add(3);
System.out.println(set); //无序性; 但不是随机的;
//[1, 2, 3, java.lang.Object@17d10166, true]
Iterator iterator = set.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
java
@Test
public void test2(){
Set set = new LinkedHashSet();
set.add(1);
set.add(2);
set.add("3");
set.add(true);
set.add(new Object());
set.add(new Object());
set.add(3);
set.add(3);
System.out.println(set); //linked 有序性;
// [1, 2, 3, 3, java.lang.Object@17d10166, java.lang.Object@1b9e1916, true]
Iterator iterator = set.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
LinkedhashSet
- 1、是HashSet的子类;
- 2、基于HashMap添加了一组双向链表,用于记录添加元素的先后顺序;
- 3、之后可按照添加元素的先后顺序进行遍历;
- 4、便于频繁的查询操作;(遍历)
HashMap:
- 1、jdk8中,使用的是数组+单向链表+红黑树的数据额结构;
- 2、
TreeSet:
- 1、数组中的item类型必须相同;
- 2、自带排序功能;
- 3、类型相同才可比较;
- 4、如果以object类型作为item;则object必须实现Comparable接口
- 5、及接口中的compareTo方法;
java
public class TreeSetTest {
@Test
public void test1(){
TreeSet treeSet = new TreeSet();
treeSet.add(1);
treeSet.add(123);
treeSet.add(13);
treeSet.add(9);
treeSet.add(32);
treeSet.add(101);
treeSet.add(19);
// treeSet.add("AA"); //只能是同一个类型;
Iterator iterator = treeSet.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
/* treeSet实现了compareable接口,默认有排序能力 */
}
}
Map
Map接口:
1、主要类
- (1)HashMap: 主要实现类;
- ①=> 线程不安全,效率高;
- ②可以添加key或value为null的值;
- ③底层:数组+单向链表+红黑树结构;
- ④Key-value 特点:
- 1)Key是不相同,且无序的;
- 2)Key的集合其实可以说是一个set;
- 3)Value是可以相同的;可以说是collection;
- 4)一个key-value 构成了一个entry;
- 5)所有的entry是不可重复,无序的;且构成一个set集合;
- 6)无序的就不存在指定位置的插入;
- ⑤子类: linkedHashMap
- 1)对比hashmap增加了双向链表;
- 2)用于记录添加的先后顺序;
- 3)遍历时可以按照添加的顺序来显示;
- 4)频繁遍历,使用此类;
- (2)Hashtable: 古老实现类
- ①=> 线程安全,效率低;
- ②不可以添加null为key或者value;
- ③底层:数组+单向链表;
- ④子类:Properties
- 1)是一个map;
- 2)Key和value是string类型;
- 3)主要用来处理属性文件;
- (3)TreeMap:
- ①底层使用的红黑树存储:(排序二叉树)
- ②可以按照key进行排序遍历;
2、区别?
方法:增删改查,长度,遍历;
TreeMap
TreeMap:
- 1、自然排序: key需要实现compareable 或compareto方法;
- 2、Key为Object类型可以重写compareable 或compareto方法自定义排序;
- 3、Comparetor订制排序;
- 4、Key必须是同一个类型;
java
public void test(){
TreeMap map = new TreeMap();
map.put("A", 1);
map.put("F", 11);
map.put("D", 12);
map.put("S", 16);
map.put("H", 18);
// map.put(1,1); //ClassCastException; 和之前的key数据类型不一致;
map.put("J", 14);
Set set = map.entrySet();
for (Object obj: set){
/* key自然排序 */
System.out.println(obj);
}
}
java
public void test2(){
/* 订制排序,再看 */
Comparator comparator = new Comparator() {
@Override
public int compare(Object o1, Object o2) {
return 0;
}
};
TreeMap map = new TreeMap(comparator);
map.put("A", 1);
map.put("F", 11);
map.put("D", 12);
map.put("S", 16);
map.put("H", 18);
Set set = map.entrySet();
for (Object obj: set){
/* key自然排序 */
System.out.println(obj);
}
}
Hashtable
略
Properties
- 继承自HashTable
- 1)是一个map;
- 2)Key和value是string类型;
- 3)主要用来处理属性文件;
结合io流使用;无例子;
java
public void test1(){
Properties properties = new Properties();
/* 需要接口File.io流使用; */
/* 用来处理文件属性内容 */
}
工具类:Collections
用途:
1、set/list/map等集合的工具类;
- 乱序,自动排序(定制化)
java
public void test1(){
List list = Arrays.asList(1,2,3,4,5,6,7);
/* fanzhuan */
Collections.reverse(list);
System.out.println(list);
/* 乱序 */
Collections.shuffle(list);
System.out.println(list);
/* 自动排序 */
Collections.sort(list);
System.out.println(list);
/* 订制话 */
Collections.sort(list, new Comparator() {
@Override
public int compare(Object o1, Object o2) {
Integer i1 = (Integer) o1;
Integer i2 = (Integer) o2;
// int v = i1.intValue() - i2.intValue();
int v = i2.intValue() - i1.intValue();
return v;
/** if(o1 instanceof Integer) {
}else {
throw new RuntimeException("bupipeide leixing");
}
*/
}
});
System.out.println(list);
}
java
public void test2(){
List list = Arrays.asList(1,2,3,4,5,6,7);
// List list2 = new ArrayList();
//IndexOutOfBoundsException: Source does not fit in dest
List list2 = Arrays.asList(new Object[list.size()]);
Collections.copy(list2,list);
System.out.println(list2);
}
@Test
public void test3(){
List list = Arrays.asList(1,2,3,4,5,6,7);
/*不可修改*/
List list2 = Collections.unmodifiableList(list);
System.out.println(list2);
/*线程安全*/
List list3 = Collections.synchronizedList(list);
Collections.rotate(list, -2);
System.out.println(list);
}
方法:
- 1、基本都是静态方法;
- 2、Reverse
- 3、Shuffle
- 4、Sort
- 5、Swap
- 6、