java——集合

已于 2023-02-08 20:47:20 修改
阅读量91 收藏
点赞数
文章标签： 算法 数据结构 java
于 2022-08-30 22:06:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_51733711/article/details/126613593
版权

集合

集合中可以存储不同的数据,可以存储任何类型(只能存储引用类型)

通过泛型,可以为集合设置一个类型,保证里面的数据类型为同一个

collection接口(单列)

里面定义了单列集合共有的方法

add() 向集合的末尾添加某一元素

addAll() 添加另一集合的全部元素(为同一类型或者有继承关系)

clear() 清空集合中的元素

equals()判断两个集合是否相等

isEmpty()判断集合是否为空

remove()删除指定的元素,成功返回true,没有换回flase

retainAll() 保留指定的元素

size() 集合的元素个数

toArray() 返回集合中所有元素的数组

list接口 List 中的数据对象有顺序且可以重复

ArrayList实现类

ArrayList实现了长度可变的数组，在内存中分配连续的空间。 遍历元素和随机访问元素的效率比较高,插入删除元素的效率比较低

常用方法:

add(int index, E element) 添加元素

get(int index) 返回该列表指定位置的元素

indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1

lastIndexOf(Object o)返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1

remove(int index) 删除并返回指定位置元素

removeRange(int fromIndex, int toIndex) 删除指定区间的元素(子类继承使用)

set(int index, E element)用指定的元素替换此列表中指定位置的元素

LinkedList实现类

LinkedList采用链表存储方式。插入、删除元素时效率比较高

常用方法:

addFirist(Object element)在该列表开头插入指定的元素

addLast(Object element)在该列表结尾插入指定的元素

get(int index)返回指定位置的元素

removeFirst()从列表删除和返回第一个元素

removeLast() 从列表删除和返回最后一个元素

getFirst() 返回列表第一个元素 getLast()返回列表最后一个元素

Vector实现类

List接口集合迭代

for循环遍历

import java.util.LinkedList;
​
public class Demo1 {
    public static void main(String[] args) {
        LinkedList <String > list=new LinkedList<>();
        list.add("a");
        list.add("d");
        list.add("c");
        list.add("a");
        list.add("d");
        /*
           for循环遍历集合,可以从中删除元素
           注:删除元素后,元素会向前移动,索引值++,可能会出现错漏问题
        */
        for (int i = 0; i <list.size() ; i++) {
            for (int j = i+1; j <list.size() ; j++) {
                if(list.get(i).equals(list.get(j))){
                    list.remove(j);
                    j--;
                }
            }
        }
        System.out.println(list);
    }
}

增强for循环的遍历

import java.util.LinkedList;
​
public class Demo1 {
    public static void main(String[] args) {
        LinkedList <String > list=new LinkedList<>();
        list.add("a");
        list.add("d");
        list.add("c");
        list.add("a");
        list.add("d");
        /*
           for循环遍历集合,可以从中删除元素
           注:删除元素后,元素会向前移动,索引值++,可能会出现错漏问题
        */
        for (int i = 0; i <list.size() ; i++) {
            for (int j = i+1; j <list.size() ; j++) {
                if(list.get(i).equals(list.get(j))){
                    list.remove(j);
                    j--;
                }
            }
        }
        System.out.println(list);
    }
}

迭代器遍历（Iterator）

import java.util.LinkedList;
​
public class Demo1 {
    public static void main(String[] args) {
        LinkedList <String > list=new LinkedList<>();
        list.add("a");
        list.add("d");
        list.add("c");
        list.add("a");
        list.add("d");
        /*
           for循环遍历集合,可以从中删除元素
           注:删除元素后,元素会向前移动,索引值++,可能会出现错漏问题
        */
        for (int i = 0; i <list.size() ; i++) {
            for (int j = i+1; j <list.size() ; j++) {
                if(list.get(i).equals(list.get(j))){
                    list.remove(j);
                    j--;
                }
            }
        }
        System.out.println(list);
    }
}

set接口 Set中所存储的元素是不重复的,但是是无序的, Set中的元素是没有索引

HashSet实现类

HashSet中的元素是不可以重复的 添加元素时调用的add()方法会判断元素是否重复

object中: public native int hashCode(); 用native修饰的方法是java不定义的,是操作系统对其定义,获取的是内存地址 public boolean equals(Object obj); 在object中,比较的是对象的地址 判断时的方法用的是hashCode()和equals(Object o) hashCode()如果调用的object中的方法,比较的是内存地址 其他类重写了该方法,比较的是计算出来的是整数型的数据,提高了比较效率 但是不安全,可能会出现哈希值相同,内容不同的情况 equals(Object o) 当哈希值相同时,就会调用该方法比较内容是否相同

import java.util.HashSet;
​
public class HashSetDemo {
    public static void main(String[] args) {
       
import java.util.Objects;
​
public  class Car implements Comparable<Car>{
    int num;
    String name;
public Car(int num, String name) {
    this.num = num;
    this.name = name;
}
​
@Override
public String toString() {
    return "Car{" +
            "num=" + num +
            ", name='" + name + '\'' +
            '}';
}
​
@Override
public int compareTo(Car o) {
    return this.num-o.num;
}
​
@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Car car = (Car) o;
    return num == car.num &&
            Objects.equals(name, car.name);
}
​
@Override
public int hashCode() {
    return Objects.hash(num, name);
}
}

TreeSet实现类

import java.util.TreeSet;
​
public class TreeDemo {
    public static void main(String[] args) {
        /*
           TreeSet:可以根据元素的自然顺序排序
           添加的元素类型,必须实现排序接口
        */
        TreeSet<String>set=new TreeSet();
        set.add("a");
        set.add("a");
        set.add("d");
        set.add("c");
        set.add("a");
        set.add("d");
        System.out.println(set);
        Car c1=new Car(1,"宝马1");
        Car c2=new Car(3,"宝马3");
        Car c3=new Car(2,"宝马2");
        TreeSet<Car>set1=new TreeSet<>();
        set1.add(c1);
        set1.add(c2);
        set1.add(c3);
        System.out.println(set1);
    }
}
import java.util.Objects;
​
public  class Car implements Comparable<Car>{
    int num;
    String name;
public Car(int num, String name) {
    this.num = num;
    this.name = name;
}
​
@Override
public String toString() {
    return "Car{" +
            "num=" + num +
            ", name='" + name + '\'' +
            '}';
}
​
@Override
public int compareTo(Car o) {
    return this.num-o.num;
}
​
@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Car car = (Car) o;
    return num == car.num &&
            Objects.equals(name, car.name);
}
​
@Override
public int hashCode() {
    return Objects.hash(num, name);
}
}

Map接口(双列)

将键映射到值的对象 一个映射不能包含重复的键 每个键最多只能映射到一个值

常用方法

V put(K key,V value) 向集合添加元素

V remove(Object key) 从该地图中删除指定键的映射（如果存在）

void clear() 清除集合

boolean containsKey(Object key)如果此映射包含指定键的映射，则返回 true 。

boolean containsValue(Object value)如果此地图将一个或多个键映射到指定值，则返回 true

boolean isEmpty()判断集合是否为空 int size() 映射的个数

V get(Object key) 返回到指定键所映射的值，或 null如果此映射包含该键的映射。

Set keySet() 返回此地图中包含的键的Set视图

entrySet() 返回此地图中包含的映射的Set视图

HashMap实现类

1.键是无序的

2.键不能重复,值可以重复

3.可以存储一个为null的键

TreeMap实现类

可以通过键进行排序,作为键的类型必须实现排序接口

HashTable实现类

是线程安全的

Map集合遍历

根据键值对对象找键和值 获取所有键值对对象的集合 遍历键值对对象的集合，获取到每一个键值对对象 根据键值对对象找键和值

import java.util.TreeSet;
​
public class TreeDemo {
    public static void main(String[] args) {
        /*
           TreeSet:可以根据元素的自然顺序排序
           添加的元素类型,必须实现排序接口
        */
        TreeSet<String>set=new TreeSet();
        set.add("a");
        set.add("a");
        set.add("d");
        set.add("c");
        set.add("a");
        set.add("d");
        System.out.println(set);
        Car c1=new Car(1,"宝马1");
        Car c2=new Car(3,"宝马3");
        Car c3=new Car(2,"宝马2");
        TreeSet<Car>set1=new TreeSet<>();
        set1.add(c1);
        set1.add(c2);
        set1.add(c3);
        System.out.println(set1);
    }
}
import java.util.Objects;
​
public  class Car implements Comparable<Car>{
    int num;
    String name;
public Car(int num, String name) {
    this.num = num;
    this.name = name;
}
​
@Override
public String toString() {
    return "Car{" +
            "num=" + num +
            ", name='" + name + '\'' +
            '}';
}
​
@Override
public int compareTo(Car o) {
    return this.num-o.num;
}
​
@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Car car = (Car) o;
    return num == car.num &&
            Objects.equals(name, car.name);
}
​
@Override
public int hashCode() {
    return Objects.hash(num, name);
}
}

Collections类

Collections为集合提供的一个工具类，类似于Arrays数组。

  
 import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
​
public class Demo12 {
    /*
    Collections
    为集合提供的一个工具类，类似于Arrays数组
    int...a
    可变长度参数
    要写在参数列表的最后，一个参数列表只能有一个可变长度参数
     */
    public static void main(String[] args) {
        //HashMap<Integer,String> hashMap=new HashMap<>();
        ArrayList<Integer> arrayList=new ArrayList<>();
        arrayList.add(1);
        arrayList.add(2);
        arrayList.add(3);
        arrayList.add(4);
        ArrayList<Integer> arrayList2=new ArrayList<>();
        arrayList2.add(0);
        arrayList2.add(0);
        arrayList2.add(0);
        arrayList2.add(0);
        arrayList2.add(0);
        Collections.addAll(arrayList,3);//将指定元素添加到指定集合
        Collections.binarySearch(arrayList,2);//使用二分查找查找指定元素
        Collections.sort(arrayList);//排序
        Collections.swap(arrayList,3,1);//将数组内元素位置替换
        Collections.copy(arrayList2,arrayList);//将数组2的元素复制到数组1中，注意：数组1的size要比数组二大
        Collections.emptyList();//返回一个空数组，不能添加数据，常用来进行逻辑比较
        Collections.fill(arrayList,6);//用指定元素替换指定集合中所有元素
        System.out.println(Collections.max(arrayList2));//输出集合中最大元素
        System.out.println(Collections.min(arrayList2));//输出集合中最小元素
        Collections.reverse(arrayList2);//反转指定集合的元素顺序
        Collections.shuffle(arrayList2);//对指定集合随机排序
   System.out.println(arrayList);
    System.out.println(arrayList2);
 
    test(10,1,2,3,4,5,6);
 
}
public static void test(int a,int...b){
    System.out.println(a);
    System.out.println(b);
}
}

泛型

泛型：参数化类型 在编译期间对类型进行检测

1.传入的参数为引用类型

2，为传入参数默认是object类型

3.可以传入多个参数

? 无界通配符

?extendT 类型通配符上限,实际传入的类型只能是T或者T的子类

?superT 类型通配符下限,实际传入的类型只能是T或者T的父类

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

未来是会发光的️

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值