Java集合框架

最新推荐文章于 2025-12-17 19:02:04 发布

原创最新推荐文章于 2025-12-17 19:02:04 发布 · 122 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java

Java集合框架

集合

概念:对象的容器，定义了对多个对象进行操作的常用方法。可实现数组的功能。
和数组的区别：
- 数组长度固定,集合长度不固定
- 数组可以存储基本类型和引用类型，集合只能存储引用类型
位置：java.util.*

Collection体系集合

Collection父接口

特点:代表一组任意类型的对象，无序、无下标、不能重复。
方法：
- boolean add(Object obj)//添加一个对象。
- boolean addAll(Collection c)//将一个集合中的所有对象添加到此集合中。.
- void clear()//清空此集合中的所有对象。
- boolean contains(Object o)//检查此集合中是否包含o对象。
- boolean equals(Object o)//比较此集合是否与指定对象相等。
- boolean isEmpty()/ /判断此集合是否为空
- boolean remove(Object o)//在此集合中移除o对象.
- int size()//返回此集合中的元素个数。
- 0bject[] toArray()//将此集合转换成数组。

增加元素

collection.add("苹果");
collection.add("西瓜");
collection.add("莲");
system.out.print1n(“元素个数:"+collection.size( ));
system.out. print1n( collection.toString()) ;

删除元素

collection .remove("莲"");
collection.clear();
system.out.printin(”删除之后:"+collection.size());

遍历元素

增强for循环

system.out.print1n("------3.1使用增强for-------");
for (object object : collection){
    system.out.println(object);
}

迭代器

//hasNext();有没有下一个元素。
//next();获取下一个元素
// remove( );删除当前元素
Iterator it=collection.iterator();
while(it.hasNext()){
    string s=(string)it.next();
    system.out.print1n(s); //不能使用collection删除方法 
    collection.remove(s);
    it.remove();
}

判断

system.out.print1n(collection.contains("西瓜"));
system.out.print1n(co1lection.isEmpty());

List子接口

特点:有序、有下标、元素可以重复。
方法
- void add(int index，0bject o)//在index位置插入对象o。
- boolean addAll(int index，Collection c)//将一个集合中的元素添加到此集合中的index位置。
- 0bject get(int index)//返回集合中指定位置的元素。
- List subList(int fromIndex,int toIndex)//返回fromIndex和toIndex之间的集合元素。

增加元素

list.add("苹果");
list.add("西瓜");
list.add("莲");
system.out.print1n(“元素个数:"+list.size( ));
system.out. print1n(list.toString()) ;

删除元素

list.remove("莲"");
list.clear();
system.out.printin(”删除之后:"+list.size());

遍历元素

增强for循环

system.out.print1n("------3.1使用增强for-------");
for (object object : list){
    system.out.println(object);
}

迭代器

//hasNext();有没有下一个元素。
//next();获取下一个元素
// remove( );删除当前元素
Iterator it=list.iterator();
while(it.hasNext()){
    string s=(string)it.next();
    system.out.print1n(s);
}

列表迭代器

//3.4使用列表选代器, 和Iterator的区别，ListIterator可以向前或向后遍历，添加、删除、修改元素
ListIterator lit=list.listIterator(;system.out.println( "------3.4使用列表选代器从前往后-------");
while(lit.hasNext()){   system.out.print1n(lit.nextIndex()+":"+lit.next());
}
system.out. println("------3.4使用列表迭代器后往前-------");
while( lit.hasPrevious()){
     system.out.println(lit.previousIndex( )+": ""+lit.previous()); 
}

判断

system.out.print1n(list.contains("西瓜"));
system.out.print1n(list.isEmpty());

获取位置

System.out.println(list.indexOf("苹果"));

补充：

list.add(20);
list.add(30);
list.add(40);
//list.remove(20);(会报错)
list.remove(0);
list.remove((Obiect)20);
list.remove(new Integer(20));

List实现类

ArrayList【重点】:
- 数组结构实现，查询快、增删慢;
- JDK1.2版本，运行效率快、线程不安全。
. Vector:
- 数组结构实现，查询快、增删慢;。
- JDK1.0版本，运行效率慢、线程安全。
LinkedList:
- 链表结构实现，增删快，查询慢。

ArrrayList使用

添加元素
删除元素
遍历元素
判断
查找

源码分析：

DEFAULT_CAPACITY()=10；默认容量大小（如果没有向集合中添加任何元素时，容量0，添加一个元素后，容量10）每次扩容大小是原来的1.5倍

elementDate 存放元素的数组

size 实际元素个数

add 添加元素

Vector

添加元素
删除元素

遍历元素

枚举器：

Enumeration en=vector.elements();
while(en.hasMoreElaments(0){
    string o=(string)en.nextElement();
    system.out.printin(o);
}

判断
查找

LinkList

添加元素
删除元素
遍历元素
- for遍历
- 增强for
- 迭代器
- 列表迭代器
判断
查找

ArrrayList和LinkList区别

ArrayList:必须开辟连续空间，查询快,增删慢。（数组）

LinkedList:无需开辟连续空间，查询慢，增删快。（链表）

泛型

Java泛型是JDK1.5中引入的一个新特性，其本质是参数化类型，把类型作为参数传递。
常见形式有泛型类、泛型接口、泛型方法。
语法：
- <T,… .>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;
    }
}

注意

泛型只能使用引用类型
不同泛型对象不能相互复制

泛型接口

不能泛型静态常量

MyInterfaceimpl impl=new NMyInterfaceImpl();
impl.server( ""xx×xX×x");       
MyInterfaceimpl impl=new NMyInterfaceImpl();
impl.server( ""xx×xX×x");//普通接口
            
MyInterfaceimpl2<Integer> impl2=new MyInterfaceImpl2<>();
impl2.server( 1000 ) ;//泛型接口

泛型方法

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

泛型集合

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

ArrayList<student> arrayList2=new ArrayList<student>() ;
student s1=new student(“刘德华”，20);
student s2=new student("郭富城"，22);
student s3=new student("梁朝伟",18);
arrayList2.add(s1);
arrayList2.add(s2);
arrayList2.add(s3);
Iterator<Student> it=arrayList2.iterator();
while(it.hasNext()){
    student s=it.next();
    system.out.print1n(s.toString);
}

Set集合

无序，没有下标
不能重复

Set接口使用

public static void main(string[] args){
    set<String> set=new Hashset<>();
}

添加元素
删除元素
遍历元素
- 增强for
- 迭代器
判断
查找

Set实现类

HashSet【重点】：
- 基于HashCode计算元素存放位置。
- 当存入元素的哈希码相同时，会调用equals进行确认，如结果为true，则拒绝后者存入。
TreeSet:
- 基于排列顺序实现元素不重复。

HashSet使用

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

HashSet<string> hashset=new HashSet<string>();

添加元素
删除元素
遍历元素
- 增强for
- 迭代器
判断
查找

HashSet存储过程

存储过程
(1)根据hashcode计算保存的位置，如果此位置为空，则直接保存，如果不为空执行第二步。

(2)再执行equals方法。如果equals方法为true，则认为是重复，否则，形成链表

补充

public int hashcode(){
    //(1)31是一个质数。减少散列冲突(2)31提高执行效率31*i=(i<<5)-i
    final int prime = 31;
    int result = 1;
    result = prime*result+age;
    result = prime*result+(name==null)?0 : name.hashcode());   
    return result;
}

TreeSet

基于排列顺序实现元素不重复。
实现了SortedSet接口，对集合元素自动排序。
元素对象的类型必须实现Comparable接口，指定排序规则。
通过CompgreTo方法确定是否为重复元素。

TreeSet使用

存储结构：红黑树
元素对象的类型必须实现Comparable接口

TreeSet<string> treehset=new TreeSet<string>();

添加元素
删除元素
遍历元素
- 增强for
- 迭代器
判断
查找

补充

Comparator：实现定制比较(比较器)

comparable：可比较的

public static void main( string[] args){
    //创建集合,并指定比较规则
    Treeset<Person> persons=new Treeset<>(new Comparator<Person>() {
        public int compare( Person oi,Person o2) {
            int ni=o1.getAge( )-o2.getAge();
            int n2=o1.getName().compareTo(o2.getName( ));
            return n1==?n2:n1;
        }
        
});

TreeSet案例

//要求:使用TreeSet集合实现字符串按概长度进行排序
//helloworld zhang lisi wangwu beijing xian nanjing
//comparator接口实现定制比较
public static void main( string[]args){
     Treeset<string treeSet=new TreeSet<>(new comparator<string>(){
     pubiic int compare(string o11, string o2){
             int n1=o1.length( )-o2.length( );
             int n2=o1.compareTo(o2);
             return ni==?n2:n1;
     }
});

Map体系集合

特点:存储一对数据(Key-Value)，无序、无下标，键不可重复，值可重复。
方法：
- v put(K key,v value)//将对象存入到集合中，关联键值。key重复则覆盖原值。
- 0bject get(Object key)//根据键获取对应的值。
- Set//返回所有key。
- Collection values()//返回包含所有值的Collection集合
- Set<Map. Entry<K, V>>//键值匹配的Set集合。

Map接口的使用

//创建Map集合
Map<String, String> map=new HashMap<>();

添加元素

map.put("cn","中国");
map.put("uk","英国");
map.put( "usa",“美国“);

删除元素
```
map.remove("usa");
```

遍历元素

使用KeySet();

Set<string> keyset=map.keyset();
for (string key : keyset){
    System.out.println(key);
}

使用entrySet()方法(效率高)

set<Map.Entry<String，String>>  entries=map.entrySet();
for (Map.Entry<String, String> entry : entries) {
    system.out.printin(entry.getKey ( )+"---------"+entry.getvalue());
}

判断

Map集合实现类

HashMap【重点】:
JDK1.2版本，线程不安全，运行效率快﹔允许用null作为key或是value。

HashMap集合的使用

存储结构：哈希表（数组+链表+红黑树）
使用Key的hashcode和equal作为重复

HashMap<student,string> students=new HashMap<Student,string>();

添加元素
删除元素
遍历元素
- 使用KeySet();
- 使用entrySet()方法(效率高)
判断

补充

HashMap刚创建时，table是null，为了节省空间，当添加第一个元素是，table容量调整为16
当元素个数大于阈值(16*0.75=12)时，会进行扩容，扩容后大小为原来的2倍。目的是减少调整元素的个数。
jdk1.8 当每个链表长度大于8，并且元素个数大于等于64时，会调整为红黑树，目的提高执行效率
jdk1.8当链表长度小于6时，调整成链表
jdk1.8以前，链表是头插入，jdk1.8以后时是尾插入

HashSet用的是HashMap

Hashtable :

JDK1.0版本，线程安全，运行效率慢;不允许null作为key或是value。

Properties :

Hashtable的子类，要求key和value都是String。通常用于配置文件的读取。

TreeMap:

实现了SortedMap接口(是Map的子接口)，可以对key自动排序。

TreeMap<student,string> treeMap=new TreeMap<student,string>();

comparable

添加元素
删除元素
遍历元素
- 使用KeySet();
- 使用entrySet()方法(效率高)
判断

Collections工具类

概念:集合工具类,定义了除了存取以外的集合常用方法。
方法：
- public static void reverse(List<?> list)//反转集合中元素的顺序
- public static void shuffle(List<?> list)//随机重置集合元素的顺序
- public static void sort(List list)//升序排序（元素类型必须实现Comparable接口)

补充

list转成数组

Integer[]arr=list.toArray( new Integer[0]);

数组转成集合（把基本类型数组转成集合时，需要修改为包装类型）

string[ ] names= {"紫三","李四",”王五"};
List<string> list2=Arrays.asList(names);//是一个受限集合,不能添加和删除