集合

用户不存在_

于 2021-05-20 08:25:03 发布

阅读量78

点赞数

分类专栏： JavaSE

本文链接：https://blog.csdn.net/m0_49902448/article/details/117060727

版权

JavaSE 专栏收录该内容

22 篇文章 1 订阅

订阅专栏

Collection

接口Collection: 单列集合

List: 有序可重复动态数组 ArrayList LinkedList Vector
Set: 无序不可重复
Map: 双列集合

Collection接口方法

测试每一次都是新的test

Collection coll = new ArrayList();//子接口的具体实现类来做测试
coll.add(123);
coll.add(456);
coll.add(new String("Tom"));
coll.add(false);
Person person = new Person("Jerry",20);
coll.add(person);

contains(Obj obj) 判断当前集合中是否包含obj

boolean contains = coll.contains(123);
System.out.println(contains);//true
System.out.println(coll.contains(new String("Tom")));//true
System.out.println(coll.contains(person));//true
System.out.println(coll.contains(new Person("Jerry",20)));//false

containsAll(Collection coll) 判断形参coll中的所有元素, 是否都存在于当前的集合中

Collection coll1 = Arrays.asList(123,456);
System.out.println(coll.containsAll(coll1));

remove移除

coll.remove(123);//移除123
System.out.println(coll);//相当于调用toString方法[456, Tom, Person{name='Jerry', age=20}, false]
coll.remove(new Person("Jerry", 20));
System.out.println(coll);//[456, Tom, false]

removeAll(Collection coll) 从当前集合中移除coll中有的元素

Collection coll1 = Arrays.asList(123,4567);
coll.removeAll(coll1);
System.out.println(coll);//[456, Tom, false]

retainAll(Collection coll) 交集, 获取当前集合和coll的交集, 并返回给当前集合

Collection coll1 = Arrays.asList(123,456,789);
coll.retainAll(coll1);
System.out.println(coll);

equals(Object obj) 判断是否相等

Collection coll3 = new ArrayList();//子接口的具体实现类来做测试
coll3.add(123);
coll3.add(456);
coll3.add(new String("Tom"));
coll3.add(new Person("Jerry",20));
coll3.add(false);
Collection coll4 = new ArrayList();//子接口的具体实现类来做测试
coll4.add(123);
coll4.add(456);
coll4.add(new String("Tom"));
coll4.add(new Person("Jerry",20));
coll4.add(false);
//equals
System.out.println(coll3.equals(coll4));//true

hashCode() 返回当前对象的哈希值

System.out.println(coll.hashCode());//-1685362349

toArray() 集合转化为数组

Object[] arr = coll.toArray();
for (int i=0; i<arr.length; i++){
    System.out.print(arr[i]);//123456TomPerson{name='Jerry', age=20}false
}

asList() 数组转化为集合

List<String> list = Arrays.asList(new String[]{"AA", "bb", "33"});
System.out.println(list);//[AA, bb, 33]
List arr1 = Arrays.asList(new int[]{123,456});
System.out.println(arr1.size());//1
List arr2 = Arrays.asList(123,456);
System.out.println(arr2);//[123, 456]
List arr3 = Arrays.asList(new Integer[]{123,456});
System.out.println(arr3.size());//2

增强for循环

for ( 集合对象局部变量 : 集合对象 ) 内部仍然调用了迭代器

Collection coll = new ArrayList();//子接口的具体实现类来做测试
coll.add(123);
coll.add(456);
coll.add(new String("Tom"));
coll.add(new Person("Jerry",20));
coll.add(false);
for (Object obj : coll){
System.out.println(obj);
}

int[] arr = new int[]{1,2,3,4,5,6};
for (int i : arr){
    System.out.println(i);
}

迭代器IteratorTest

找到Tom删除它, 之后遍历集合

Collection coll = new ArrayList();//子接口的具体实现类来做测试
coll.add(123);
coll.add(456);
coll.add(new String("Tom"));
coll.add(new Person("Jerry",20));
coll.add(false);

Iterator iterator = coll.iterator();
while (iterator.hasNext()){
    Object obj = iterator.next();
    if ("Tom".equals(obj)){
        iterator.remove();
    }
}

Iterator iterator1 = coll.iterator();
while (iterator1.hasNext()){
    System.out.println(iterator1.next());
}

List

ArrayList,LinkedList,Vector三者的异同?

同:

三个类都是实现类List接口, 存储数据的特点相同:存储有序的可重复的数据

不同:

ArrayList: 作为List的主要接口, 效率高, 线程不安全, 底层使用Object[] elementData存储

LinkedList: 对于频繁的插入和删除操作, 使用这个效率高, 底层使用双向链表存储

vector: 作为list接口的古老实现类, 效率低, 线程安全, 底层使用Object[] elementData存储

创建集合

ArrayList list = new ArrayList();
list.add(123);
list.add(456);
list.add("AA");
list.add(new Person("Tom",12));
list.add(456);
System.out.println(list);//[123, 456, AA, Person{name='Tom', age=12}, 456]

List方法

void add(int index, Object ele) 在index位置插入ele元素

list.add(1,"BB");
System.out.println(list);//[123, BB, 456, AA, Person{name='Tom', age=12}, 456]

addAll(int index, Collection ele) 从index位置开始将ele中的所有元素添加

List list1 = Arrays.asList(1,2,3);
list.addAll(list1);//addAll!!!
System.out.println(list.size());//9

int indexOf(Object obj) 返回obj在集合中首次出现的位置

int index = list.indexOf(456);
System.out.println(index);//1 如果不存在,则返回-1

int lastIndexOf(Object obj) 返回obj在当前集合中末次出现的位置

System.out.println(list.lastIndexOf(456));//4

remove 删除指定索引位置元素并返回元素

Object obj = list.remove(0);
System.out.println(obj);

Object set(int index, Object obj) 设置指定index位置的元素为ele

list.set(1,"CC");
System.out.println(list);//[456, CC, Person{name='Tom', age=12}, 456]

List subList(int fromIndex, int toIndex) 返回左闭右开区间

List subList = list.subList(2,4);
System.out.println(subList);//[Person{name='Tom', age=12}, 456]

遍历list

ArrayList list = new ArrayList();
list.add(123);
list.add(456);
list.add("AA");
//①Iterator迭代器方式
Iterator iterator = list.iterator();
while (iterator.hasNext()){
    System.out.println(iterator.next());
}
//②增强for循环
for (Object obj : list){
    System.out.println(obj);
}
//③普通的循环
for (int i=0; i<list.size(); i++){
    System.out.println(list.get(i));
}

Person

public class Person implements Comparable{
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        System.out.println("Person...");
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Person person = (Person) o;

        if (age != person.age) return false;
        return name != null ? name.equals(person.name) : person.name == null;
    }

    //按照姓名从小到大排序
    @Override
    public int compareTo(Object o) {
        if (o instanceof Person){
            Person person = (Person) o;
            return this.name.compareTo(person.name);
        }else {
            throw new RuntimeException("输入的类型不匹配");
        }
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
}

Set TreeSet

向TreeSet中添加的数据, 要求是相同类的对象

TreeSet set = new TreeSet();
//错误,不能添加不同类的对象
//        set.add(123);
//        set.add(456);
//        set.add("AA");
//        set.add(new Person("Tom",12));

TreeSet set = new TreeSet();
set.add(34);
set.add(-34);
set.add(43);
set.add(11);
set.add(8);

遍历默认从小到大排序

Iterator iterator = set.iterator();
while (iterator.hasNext()){
    System.out.print(iterator.next()+" ");//-34 8 11 34 43 从小到大排序
}

遍历+1

TreeSet set = new TreeSet();
set.add(new Person("Apple",1));
set.add(new Person("Apple",2));
set.add(new Person("Dog",2));
set.add(new Person("Cat",2));
set.add(new Person("Bird",2));

Iterator iterator = set.iterator();
while (iterator.hasNext()){
    System.out.println(iterator.next());
}
/*
Person{name='Apple', age=1}
Person{name='Bird', age=2}
Person{name='Cat', age=2}
Person{name='Dog', age=2}
 */

遍历+2 comparator按年龄从小到大排列

Comparator comparator = new Comparator() {
    //按照年龄从小到大排列
    @Override
    public int compare(Object o1, Object o2) {
        if (o1 instanceof Person && o2 instanceof Person){
            Person person1 = (Person) o1;
            Person person2 = (Person) o2;
            return Integer.compare(person1.getAge(),person2.getAge());
        }else {
            throw new RuntimeException("输入的数据类型不匹配");
        }
    }
};
TreeSet set = new TreeSet(comparator);
set.add(new Person("Apple",1));
set.add(new Person("Applee",1));
set.add(new Person("Dog",4));
set.add(new Person("Cat",3));
set.add(new Person("Bird",2));

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

Map 理论理解

HashMap: 作为Map的主要实现类, 线程不安全的, 效率高, 存储null的key和value
- LinkedHashMap: 保证在遍历map元素时, 可以按照添加的顺序实现遍历, 原因: 在原有的HashMap底层结构基础上, 添加了一对指针, 指向前一个和后一个元素, 对于频繁的遍历操作, 此类执行效率高于HashMap
TreeMap: 保证按照添加的key-value对进行排序, 实现排序遍历. 此时考虑key的自然排序或定制排序, 磁层使用红黑树
Hashtable: 作为Map的古老实现类, 线程安全的, 效率低, 不能存储null的key和value
Properties: 常用来处理配置文件key和value都是String类型
Map结构的理解
Map中的key: 无序的, 不可重复的, 使用Set存储所有的key–>key所在的类要重写equals()方法和hashCode()
Map中的value: 无序的, 可重复的, 使用Collection存储所有的value
一个键值对: key-value构成了一个Entry对象
Map中的entry: 无序的,不可重复的,使用Set存储所有的entry
HashMap的底层实现原理,以jdk7为实例说明

HashMap map = new HashMap();

在实例化以后, 底层创建了长度是16的一维数组Entry[] table

…可能已经执行过多次put…

map.put(key1,value1) :

首先, 调用key1所在类的hashCode()计算key1哈希值, 此哈希值经过某种算法计算以后, 得到在Entry数组中的存放位置

如果此位置上的数据为空, 此时key1-value1添加成功

如果此位置上的数据不为空, (意味着此位置上存在一个或多个数据(以链表形式存在)), 比较key1和已经存在的一个或多个数据的哈希值

如果key1的哈希值与已经存在的数据的哈希值都不相同, 此时key1-value1添加成功

如果key1的哈希值和已经存在的某一个数据的哈希值相同, 继续比较:调用key1所在类的equals()方法

比较, 如果返回false:添加成功. true:value1替换value2
jdk8相较于jdk7在底层实现方面的不同
1. new HashMap(): 底层没有创建一个长度为16的数组
2. jdk8底层数组是: Node[], 而非Entry[]
3. 首次调用put()方法时, 底层创建长度为16的数组
4. jdk7底层: 数组+链表 jdk8底层: 数组+链表+红黑树

Map方法

Object put(Object key, Object value) 将指定的key-value添加到(或修改)当前map对象中

Map map = new HashMap();
//添加
map.put("AA",123);
map.put(45,123);
map.put("BB",56);
//修改
map.put("AA",87);
System.out.println(map);//{AA=87, BB=56, 45=123}

Object putAll(Map m) 将m中所有key-value对存放到当前map中

Map map1 = new HashMap();
map1.put("CC",123);
map1.put("DD",123);
map.putAll(map1);
System.out.println(map);//{AA=87, BB=56, CC=123, DD=123, 45=123}

Object remove(Object key) 移除指定key的key-value对, 并返回value

Object value = map.remove("CC");
System.out.println(value);//123
System.out.println(map);//{AA=87, BB=56, DD=123, 45=123}
System.out.println(map.remove("CC"));//null

void clear() 清空当前map中的所有数据

map.clear();//清空map集合里的内容
System.out.println(map.size());//0
System.out.println(map);//{}

Object get(Object key) 获取指定key对应的value

Map map = new HashMap();
map.put("AA",123);
map.put(45,123);
map.put("BB",56);
//get
System.out.println(map.get(45));//123
System.out.println(map.get(455));//null

boolean containsKey(Object key) 是否含指定的key

boolean isExist = map.containsKey("BB");
System.out.println(isExist);//true

boolean containsValue 是否包含指定的value

boolean isValue = map.containsValue(123);
System.out.println(isValue);//true 如果找到第一个,则不继续向下找

boolean isEmpty() 判断当前map是否为空

map.clear();
System.out.println(map.isEmpty());//true

Set keySet() 返回所有key构成的Set集合

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.print(iterator.next()+" ");//AA BB 45
}

Collection value() 返回所有value构成的collection集合

//遍历所有的value
Collection values = map.values();
for (Object obj : values){
    System.out.print(obj+" ");//123 56 1234
}

set entrySet() 返回所有key-value对构成的Set集合

//遍历所有的key-value
Set entrySet = map.entrySet();//alt+enter
Iterator iterator1 = entrySet.iterator();
while (iterator1.hasNext()){
    Object obj = iterator1.next();
    //entrySet集合中的元素都是Entry
    Map.Entry entry = (Map.Entry) obj;//强转是为了获取get方法
    System.out.println(entry.getKey()+"-->"+entry.getValue());
    //AA-->123
    //BB-->56
    //45-->1234
}
//遍历所有的key-value方式二
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);
    //AA~~~123
    //BB~~~56
    //45~~~1234
}

Collections工具类

Collections是一个操作Set, List, Map等集合的工具类

reverse(List) 反转List中元素的顺序

List list = new ArrayList();
list.add(123);
list.add(43);
list.add(765);
list.add(-97);
list.add(0);
System.out.println(list);//[123, 43, 765, -97, 0]
Collections.reverse(list);
System.out.println(list);//[0, -97, 765, 43, 123]

shuffle(List) 对List集合元素进行随机排序

Collections.shuffle(list);
System.out.println(list);//[-97, 123, 765, 43, 0]每次不一样

sort(List) 根据元素的自然顺序对指定List集合元素按升序排序

Collections.sort(list);
System.out.println(list);//[-97, 0, 43, 123, 765]

swap(List, int, int) 将指定list集合中i处元素和j处元素进行交换

Collections.swap(list,1,2);
System.out.println(list);//[-97, 43, 0, 123, 765]

Object max(Collection) 根据元素的自然顺序, 返回给定集合中的最大元素
Object max(Collection, Comparator) 根据Comparator指定的顺序, 返回给定集合中的最大元素
Object min(Collection)
Object min(Collection, Comparator)
int frequency(Collection, Object) 返回指定集合中指定元素出现的次数

int frequency = Collections.frequency(list,765);
System.out.println(frequency);//1

void copy(List dest, List src) 将src中的内容复制到dest中

List dest = new ArrayList();
dest.add(123);
dest.add(123);
dest.add(123);
dest.add(123);
dest.add(123);
dest.add(123);
dest.add(123);
Collections.copy(dest,list);//dest必须比list大
System.out.println(dest);//[-97, 43, 0, 123, 765, 123, 123]
//直接恰好大小的技巧
List dest1 = Arrays.asList(new Object[list.size()]);
Collections.copy(dest1,list);
System.out.println(dest1);//[-97, 43, 0, 123, 765]
//返回的list1即为线程安全的list
List list1 = Collections.synchronizedList(list);

boolean replaceAll(List list, Object oldVal, Object newVal) 使用新值替换List对象的所有旧值

TreeMap

向TreeMap中添加key-value要求key必须是由同一个类创建的对象

因为要按照key进行排序: 自然排序, 定制排序

自然排序

TreeMap map = new TreeMap();
Person person1 = new Person("AA",23);
Person person2 = new Person("CC",32);
Person person3 = new Person("BB",20);
Person person4 = new Person("CC",18);
map.put(person1,98);
map.put(person2,89);
map.put(person3,76);
map.put(person4,100);
Set entrySet = map.entrySet();//alt+enter
Iterator iterator1 = entrySet.iterator();
while (iterator1.hasNext()){
    Object obj = iterator1.next();
    //entrySet集合中的元素都是Entry
    Map.Entry entry = (Map.Entry) obj;//强转是为了获取get方法
    System.out.println(entry.getKey()+"-->"+entry.getValue());
    //Person{name='AA', age=23}-->98
    //Person{name='BB', age=20}-->76
    //Person{name='CC', age=32}-->100
}

定制排序 Comparator

TreeMap map = new TreeMap(new Comparator() {
    @Override
    public int compare(Object o1, Object o2) {
        if (o1 instanceof Person && o2 instanceof Person){
            Person person1 = (Person) o1;
            Person person2 = (Person) o2;
            return Integer.compare(person1.getAge(), person2.getAge());
        }
        throw new RuntimeException("输入的类型不匹配");
    }
});
Person person1 = new Person("AA",23);
Person person2 = new Person("CC",32);
Person person3 = new Person("BB",20);
Person person4 = new Person("CC",18);
map.put(person1,98);
map.put(person2,89);
map.put(person3,76);
map.put(person4,100);

Set entrySet = map.entrySet();//alt+enter
Iterator iterator1 = entrySet.iterator();
while (iterator1.hasNext()){
    Object obj = iterator1.next();
    //entrySet集合中的元素都是Entry
    Map.Entry entry = (Map.Entry) obj;//强转是为了获取get方法
    System.out.println(entry.getKey()+"-->"+entry.getValue());
    //Person{name='CC', age=18}-->100
    //Person{name='BB', age=20}-->76
    //Person{name='AA', age=23}-->98
    //Person{name='CC', age=32}-->89
}

联系一点io

//Properties: 常用来处理配置文件, key和value都是String类型
public static void main(String[] args){
    FileInputStream fileInputStream = null;
    try {
        Properties properties = new Properties();
        fileInputStream = new FileInputStream("jdbc.properties");
        properties.load(fileInputStream);//加载流对应的文件
        String name = properties.getProperty("name");
        String password = properties.getProperty("password");
        System.out.println(name+password);//Dad123
    } catch (IOException e) {
        //全选ctrl+alt+t直接出来try-catch-finally
        e.printStackTrace();
    } finally {
        if (fileInputStream != null) {
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}