集合

集合

集合和数组的区别：

1.数组长度固定，集合长度不固定。

2.数组可以存储基本类型和引用类型，集合只能存储引用类型。

所有的集合都是在Collection下面。分为List接口和Set接口：其中List接口有序、有下标、元素可以重复；Set接口无序、无下标、元素不能重复。

 

package object;
​
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
​
public class Demo1 {
    public static void main(String[] args) {
        ArrayList<Object> obj = new ArrayList<>();
        obj.add("苹果");
        obj.add("香蕉");
        obj.add("菠萝");
        System.out.println(obj.size());
        System.out.println(obj);
​
        //删除元素
//        obj.remove("香蕉");
//        System.out.println(obj.size());
​
        //遍历
        for (Object obj1 :
                obj) {
            System.out.println(obj1);
        }
​
        //使用迭代器（专门用来遍历集合的一种方式）
        //hasNext：是否有下一个元素
        //next:获取下一个元素
        //remove:删除当前元素
        Iterator<Object> iterator = obj.iterator();
        while (iterator.hasNext()){
            String object=(String)iterator.next();
            System.out.println(object);
        }
​
        //判断集合中是否包含某种元素
        System.out.println(obj.contains("苹果"));
​
        //for
        for (int i = 0; i < obj.size(); i++) {
            System.out.println(obj.get(i));
        }
​
        //ListItertor
        ListIterator listIterator=obj.listIterator();
        while (listIterator.hasNext()){
            System.out.println(listIterator.next());
        }
        while (listIterator.hasPrevious()){
            System.out.println(listIterator.previous());
        }
​
        //判断
        System.out.println(obj.contains("苹果"));
​
        //获取元素下标
        System.out.println(obj.indexOf("香蕉"));
​
    }
}

 

泛型

把类型作为参数传递。

好处：提高代码的重用性。防止类型转换异常，提高代码的安全性。

/**
 *泛型类
 * 语法：类名<T>
 * T表示类型占位符，表示一种引用类型，如果编写多个使用逗号隔开。
 * @param <T>
 */
public class Demo2<T> {
    /**
     *
     */
    //创建变量
    T t;
​
    //作为方法的参数
    public void show(T t){
        System.out.println(t);
    }
​
    //作为方法的返回值
    public T getT(){
        return t;
    }
}
public class APP {
    public static void main(String[] args) {
​
        //使用泛型类创建对象
        //注意：1.泛型只能使用引用类型。2.不同泛型对象之间不能相互复制。
        Demo2<String> objectDemo2 = new Demo2<>();
        objectDemo2.t="hello";
        objectDemo2.show("dajiahao");
        String string=objectDemo2.getT();
​
        Demo2<Integer> objectDemo21 = new Demo2<>();
        objectDemo21.t=123;
        objectDemo21.show(200);
        Integer integer=objectDemo21.getT();
    }
}

 

泛型接口

import java.util.SplittableRandom;
​
/**
 * 泛型接口
 * 语法：接口名<T>
 * 注意：不能泛型里写静态常量
 * @param <T>
 */
public interface Myinterface<T> {
    String name="张三";
​
    T sever(T t);
}
//在实现泛型接口的时候需要指明泛型T的类型。
public class MyInterfaceImpl implements Myinterface<String>{
    @Override
    public String sever(String s) {
        return null;
    }
}

 

 

泛型方法

public class Demo3 {
    public <T> void show(T t){
        System.out.println(t);
    }
}
//泛型方法调用
//泛型方法被调用的时候，不需要指明泛型类型。
Demo3 demo3 = new Demo3();
demo3.show("hello");
demo3.show(200);

 

 

集合使用泛型的原因

集合在使用泛型时指定泛型的类型，可以确定能够写入该集合的数据类型，以免在后续强转的过程中存在产生错误。

 

hashSet的使用

hashset的存储结构：哈希表（数组+链表+红黑树）

基于HasdCode计算元素存放位置。

当存入元素的哈希码相同时，会调用equals进行确认，如结果为true，则拒绝后者存入。

 

TreeSet

基于排序实现元素不重复。

实现了SortedSet接口，对集合元素自动排序。

元素对象的类型必须实现Comparable接口，指定排序规则。

通过CompareTo方法确定是否存在重复元素。

 

Map集合

Map接口的特点：

1.用于存储任意键值对（Key-Value）。

2.键：无序、无下标、不允许重复（唯一）。

2.值：无序、无下标、允许重复。

 

方法：

put：将对象存入集合中。相同key，则后入覆盖陷入。

get：获取指定键的值。

keySet：返回所有的key。

Collection values：返回包含所有值得Collection。

Set：简直匹配的Set集合。

package object;
​
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
​
public class Demo4 {
    public static void main(String[] args) {
        //创建Map集合
        HashMap<String, String> map = new HashMap<>();
        //添加元素
        map.put("1","a");
        map.put("2","b");
        map.put("3","c");
​
        //删除remove
​
        //遍历
        //使用keySet遍历
        Set<String> keyset = map.keySet();
        for (String key :
                keyset) {
            System.out.println(map.get(key));
        }
​
        //使用enterSet方法遍历
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> entry :
                entries) {
            System.out.println(entry.getKey()+"*--*"+entry.getValue());
​
        }
​
        //判断 
        System.out.println(map.containsKey("1"));
    }
}

 

Collections工具类的使用

  1. sort排序

  2. binarySearch二分查找

  3. copy复制

  4. reverse反转

  5. shuffle打乱

基本使用格式：Collections.方法名（集合）

 

list转成数组：

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

 

数组转成集合list：（转换后得到的集合是一个受限集合，不能产生添加和删除操作 。）

Lsit<String> list2=Arrays.aslist(数组);

将基本类型数组转换成集合时，需要修改为包装类。比如int[] nums需要写成Integer[] nums。

# 集合
---
集合和数组的区别：
1.数组长度固定，集合长度不固定。
2.数组可以存储基本类型和引用类型，集合只能存储引用类型。
所有的集合都是在Collection下面。分为List接口和Set接口：其中List接口有序、有下标、元素可以重复；Set接口无序、无下标、元素不能重复。


```javapackage object;
import java.util.ArrayList;import java.util.Iterator;import java.util.ListIterator;
public class Demo1 {    public static void main(String[] args) {        ArrayList<Object> obj = new ArrayList<>();        obj.add("苹果");        obj.add("香蕉");        obj.add("菠萝");        System.out.println(obj.size());        System.out.println(obj);
        //删除元素//        obj.remove("香蕉");//        System.out.println(obj.size());
        //遍历        for (Object obj1 :                obj) {            System.out.println(obj1);        }
        //使用迭代器（专门用来遍历集合的一种方式）        //hasNext：是否有下一个元素        //next:获取下一个元素        //remove:删除当前元素        Iterator<Object> iterator = obj.iterator();        while (iterator.hasNext()){            String object=(String)iterator.next();            System.out.println(object);        }
        //判断集合中是否包含某种元素        System.out.println(obj.contains("苹果"));
        //for        for (int i = 0; i < obj.size(); i++) {            System.out.println(obj.get(i));        }
        //ListItertor        ListIterator listIterator=obj.listIterator();        while (listIterator.hasNext()){            System.out.println(listIterator.next());        }        while (listIterator.hasPrevious()){            System.out.println(listIterator.previous());        }
        //判断        System.out.println(obj.contains("苹果"));
        //获取元素下标        System.out.println(obj.indexOf("香蕉"));
    }}```


#### 泛型
---
把类型作为参数传递。
好处：提高代码的重用性。防止类型转换异常，提高代码的安全性。
```java/** *泛型类 * 语法：类名<T> * T表示类型占位符，表示一种引用类型，如果编写多个使用逗号隔开。 * @param <T> */public class Demo2<T> {    /**     *     */    //创建变量    T t;
    //作为方法的参数    public void show(T t){        System.out.println(t);    }
    //作为方法的返回值    public T getT(){        return t;    }}```
```javapublic class APP {    public static void main(String[] args) {
        //使用泛型类创建对象        //注意：1.泛型只能使用引用类型。2.不同泛型对象之间不能相互复制。        Demo2<String> objectDemo2 = new Demo2<>();        objectDemo2.t="hello";        objectDemo2.show("dajiahao");        String string=objectDemo2.getT();
        Demo2<Integer> objectDemo21 = new Demo2<>();        objectDemo21.t=123;        objectDemo21.show(200);        Integer integer=objectDemo21.getT();    }}```


#### 泛型接口
---
```javaimport java.util.SplittableRandom;
/** * 泛型接口 * 语法：接口名<T> * 注意：不能泛型里写静态常量 * @param <T> */public interface Myinterface<T> {    String name="张三";
    T sever(T t);}```
```java//在实现泛型接口的时候需要指明泛型T的类型。public class MyInterfaceImpl implements Myinterface<String>{    @Override    public String sever(String s) {        return null;    }}```




#### 泛型方法
---
```javapublic class Demo3 {    public <T> void show(T t){        System.out.println(t);    }}```
```java//泛型方法调用//泛型方法被调用的时候，不需要指明泛型类型。Demo3 demo3 = new Demo3();demo3.show("hello");demo3.show(200);```




### 集合使用泛型的原因
---
​集合在使用泛型时指定泛型的类型，可以确定能够写入该集合的数据类型，以免在后续强转的过程中存在产生错误。


### hashSet的使用
---
hashset的存储结构：哈希表（数组+链表+红黑树）
基于HasdCode计算元素存放位置。
当存入元素的哈希码相同时，会调用equals进行确认，如结果为true，则拒绝后者存入。


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


## Map集合
---
Map接口的特点：
1.用于存储任意键值对（Key-Value）。
2.键：无序、无下标、不允许重复（唯一）。
2.值：无序、无下标、允许重复。


方法：
put：将对象存入集合中。相同key，则后入覆盖陷入。
get：获取指定键的值。
keySet：返回所有的key。
Collection values：返回包含所有值得Collection。
Set：简直匹配的Set集合。
```javapackage object;
import java.util.HashMap;import java.util.Map;import java.util.Set;
public class Demo4 {    public static void main(String[] args) {        //创建Map集合        HashMap<String, String> map = new HashMap<>();        //添加元素        map.put("1","a");        map.put("2","b");        map.put("3","c");
        //删除remove
        //遍历        //使用keySet遍历        Set<String> keyset = map.keySet();        for (String key :                keyset) {            System.out.println(map.get(key));        }
        //使用enterSet方法遍历        Set<Map.Entry<String, String>> entries = map.entrySet();        for (Map.Entry<String, String> entry :                entries) {            System.out.println(entry.getKey()+"*--*"+entry.getValue());
        }
        //判断         System.out.println(map.containsKey("1"));    }}```
 
### Collections工具类的使用
---
1. sort排序2. binarySearch二分查找3. copy复制4. reverse反转5. shuffle打乱
基本使用格式：Collections.方法名（集合）


list转成数组：
Integer[] arr=list.toArray(new Integer[0])；


数组转成集合list：（转换后得到的集合是一个受限集合，不能产生添加和删除操作 。）
Lsit<String> list2=Arrays.aslist(数组);
将基本类型数组转换成集合时，需要修改为包装类。比如int[] nums需要写成Integer[] nums。

posted @ 2021-11-01 17:29  用余生去爱  阅读(105)  评论(0)    收藏  举报