Java集合框架

1. 集合概念

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

2. 集合和数组的区别

数组长度固定，集合长度不固定
数组能储存基本类型和引用类型，集合只能储存引用类型

3. Collection体系结构

4. Collection常用方法

添加元素：collection.add()
删除元素：collection.remove() collection.clear()
遍历元素：
1. 使用增强for（因为没有下标）
  for(Object object : collection)
2. 使用迭代器
代码如下

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

判断元素：collection.contains() collection.isEmpty()

5. List子接口

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

6. List常用方法

添加元素：list.add( ); 会对基本类型进行自动装箱
删除元素：可以用索引 list.remove(0) ; 当索引和删除元素数字重复时，可以对数字进行强转list.remove((Object) 10)或list.remove(new Integer(10))
遍历元素：

1.使用for循环

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

2.使用增强for

		for(Object object : list){ }

3.使用迭代器

		Iterator it=list.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}

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()); //从	后往前遍历
		}

5.判断元素

		list.contains();
		list.isEmpty();

6.补充

		list.subList();//返回子集合，左闭右开，例如subList(1,3)，返回索引为1和2的元素
		list.indexOf();//定位

7. List实现类

ArrayList
- 数组结构实现，必须要连续空间，查询快、增删慢
- jdk1.2版本，运行效率块、线程不安全
Vector
- 数组结构实现，查询快、增删慢
- jdk1.0版本，运行效率块、线程不安全
LinkedList
- 链表结构实现，无需连续空间，增删快，查询慢

8. ArrayList

创建集合：ArrayList arrayList = new ArrayList<>();
删除元素：arrayList.remove(new Student("name",22)); 这里重写了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;
}

遍历元素

使用迭代器

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

使用列表迭代器

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

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

9. Vector

创建集合：Vector vector=new Vector<>();
添加、删除、判断同上
遍历元素

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

10. LinkedList

创建链表集合LinkedList li = new LinkedList<>();
常用方法和ArrayList一致

11. ArrayList和LinkedList的区别

12. 泛型

本质是参数化类型，把类型作为参数传递
常见形式有泛型类、泛型接口、泛型方法
好处 1. 提高代码重用性 2. 防止类型转换异常，提高代码安全性

13. 泛型类

创建泛型类

/**
 * 泛型类
 * 语法：类名<T>
 * T是类型占位符，表示一种引用类型，如果编写多个需要用逗号隔开
 * @param <T>
 */
public class MyGeneric<T>{
    //使用泛型T
    //1. 创建变量
    T t;
    //2. 泛型作为方法的参数
    public void show(T t){
        System.out.println(t);
    }
    //3. 泛型作为方法的返回值
    public T getT(){
        return t;
    }
}

测试泛型类

public class TestGeneric {
    public static void main(String[] args) {
        //使用泛型类创建对象
        MyGeneric<String> myGeneric=new MyGeneric<>();
        myGeneric.t="F**k";
        myGeneric.show("You");
        String s=myGeneric.getT();
    }
}

14. 泛型接口

创建泛型接口

/**
 * 泛型接口
 * 语法：接口名<T>
 * 注意：不能泛型静态常量
 * @param <T>
 */
public interface MyInterface<T>{
    String name="hello";
    T server(T t);
}

实现泛型接口
- public class MyInterfaceImpl implements MyInterface{}
- public class MyInterfaceImpl implements MyInterface{}

15. 泛型方法

创建泛型方法

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

实现泛型方法

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

16. 泛型集合

概念：参数化类型、类型安全的集合，强制集合元素的类型必须一致
特点：
- 编译时即可检查，而非运行时抛出异常
- 访问时，不必类型转换（拆箱）
- 不同泛型之间应用不能相互赋值，泛型不存在多态

17. Set集合

特点：无序、无下标、元素不可重复
方法：全部继承自Collection中的方法，增、删、遍历、判断与collection一致
实现类：HashSet和TreeSet

18. HashSet

存储结构：哈希表（数组+链表+红黑树）
存储过程（重复依据）
- 根据hashCode计算保存的位置，如果位置为空，直接保存，若不为空，进行第二步
- 再执行equals方法，如果equals为true，则认为是重复，否则形成链表

/**
 * HashSet集合的使用
 * 储存结构：哈希表（数组+链表+红黑树）
 */
public class MyHashSet {
    public static void main(String[] args) {
        HashSet<String> hashSet=new HashSet<>();

        //1 添加元素
        hashSet.add("刘德华");
        hashSet.add("张三");
        hashSet.add("李四");
        hashSet.add("王二");
        System.out.println("元素个数"+hashSet.size());
        System.out.println(hashSet.toString());

        //2 删除元素
        hashSet.remove("刘德华");
        //3 遍历
        //3.1 使用增强for
        for (String string:
             hashSet) {
            System.out.println(string);
        }
        //3.2 使用迭代器
        Iterator<String> it=hashSet.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }

        //4 判断
        System.out.println(hashSet.contains("刘德华"));
        System.out.println(hashSet.isEmpty());
    }
}

19. TreeSet

特点
- 基于排列顺序实现元素不重复
- 实现SortedSet接口，对集合元素自动排序
- 元素对象的类型必须实现Comparable接口，指定排序规则
存储结构：红黑树
创建集合 TreeSet treeSet = new TreeSet<>()；
其他操作同上
补充：

示例：

实现Comparable接口，重写compareTo方法：

@Override
public int compareTo(Person o) {
    int n1 = this.getName().compareTo(o.getName());
    int n2 = this.getAge() - o.getAge();
    return n1 == 0 ? n2 : n1;
}

实现Comparator接口，实现定制化比较：

TreeSet<Person> treeSet = new TreeSet<>(new Comparator<Person>() { // 匿名内部类
    @Override
    public int compare(Person o1, Person o2) {
        int n1 = o1.getName().compareTo(o2.getName());
        int n2 = o1.getAge() - o2.getAge();
        return n1 == 0 ? n2 : n1;
    }
});

20. Map集合

Map接口的特点：
- 用于存储任意键值对（key - value）
- 键：无序、无下标、不允许重复（唯一）
- 值：无序、无下标、允许重复

21. Map接口的使用

示例代码如下：

/**
 * Map接口的使用
 */
public class MyMap {
    public static void main(String[] args) {
        // 创建Map集合
        Map<String, String> map = new HashMap<>();

        // 1 添加元素
        map.put("cn", "中国");
        map.put("uk", "英国");
        map.put("usa", "美国");
        map.put("cn", "zhongguo"); // 会替换第一个
        System.out.println("元素个数" + map.size());
        System.out.println(map.toString());

        // 2 删除
        map.remove("usa");

        // 3 遍历
        // 3.1 使用keySet
        for (String key :
                map.keySet()) {
            System.out.println(key + "---" + map.get(key));
        }
        
        // 3.2 使用entrySet
        for (Map.Entry<String,String> entry :
                map.entrySet()) {
            System.out.println(entry.getKey() + "--" + entry.getValue());
        }
    }
}

22. HashMap接口的使用

示例代码如下：

package cn.pearbook.demo;

import java.util.HashMap;

/**
 * HashMap
 * 存储结构：哈希表（数组+链表+红黑树）
 * 默认判断元素重复依据是Key的hashcode和equals方法，它们使用对象的地址进行判断，示例代码19-20行
 */
public class MyHashMap {
    public static void main(String[] args) {
        // 创建hashmap集合
        HashMap<Student, String> students = new HashMap<>();
        //1 添加元素
        students.put(new Student("zhangsan",1000),"1");
        students.put(new Student("lisi",1001),"2");
        students.put(new Student("wanger",1002),"3");
        students.put(new Student("zhaowu",1003),"4");
//        students.put(new Student("zhaowu",1003),"5");
//        System.out.println(students.size()); // 若不重写hashcode\equals,输出为5
        System.out.println(students.size());
        //其他类似Map接口
    }
}

23. Hashtable和Properties

Hashtable：线程安全，运行效率慢；不允许null作为key或是value
Properties：hashtable的子类，要求key和value都是string，通常用于配置文件的读取

24. TreeMap

实现了SortedMap接口（是map的子接口），可以对key自动排序

逻辑和示例代码类似TreeSet

25. Collections工具类

package cn.pearbook.demo;

import java.util.*;

public class CollectionTools {
    public static void main(String[] args) {
        List<Integer> list=new ArrayList<>();
        list.add(1);
        list.add(5);
        list.add(4);
        list.add(16);
        list.add(13);

        //sort排序
        Collections.sort(list);
        System.out.println(list.toString());

        //binarySearch
        int index=Collections.binarySearch(list, 4);
        System.out.println(index);

        //copy
        List<Integer> list1 = new ArrayList<>();
        for (int i=0;i<list.size();i++){
            list1.add(0);
        }
        Collections.copy(list1,list);
        System.out.println(list1.toString());

        //reverse
        Collections.reverse(list);
        System.out.println(list.toString());

        //shuffle 打乱
        Collections.shuffle(list);
        System.out.println(list.toString());

        // list转成数组
        Integer[] arr = list.toArray(new Integer[0]);
        System.out.println(arr.length);
        System.out.println(Arrays.toString(arr));

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

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

🔚

posted @ 2022-05-22 15:58 RichieLe 阅读(28) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· Java I/O框架

· JavaEE平台技术

· Java集合框架

· JAVA集合框架学习笔记

· Java集合笔记

公告

昵称： RichieLe
园龄： 4年11个月
粉丝： 1
关注： 4

+加关注

2025年3月

日

一

二

三

四

五

六

Java集合框架

Java集合框架

1. 集合概念

2. 集合和数组的区别

3. Collection体系结构

4. Collection常用方法

5. List子接口

6. List常用方法

7. List实现类

8. ArrayList

9. Vector

10. LinkedList

11. ArrayList和LinkedList的区别

12. 泛型

13. 泛型类

14. 泛型接口

15. 泛型方法

16. 泛型集合

17. Set集合

18. HashSet

19. TreeSet

20. Map集合

21. Map接口的使用

22. HashMap接口的使用

23. Hashtable和Properties

24. TreeMap

25. Collections工具类

公告

搜索

常用链接

我的标签

随笔分类

随笔档案

阅读排行榜