09.集合

集合

image-20241122163640181 image-20241122165916368

Collection（单列集合）

Collection是单列集合祖宗接口，其全部单列集合都可以使用。

创建其实现类的对象。arraylist

boolean add(E e)//增 可重复时，返回值为true  不可重复，若重复返回值为false
boolean remove(E e)//删   不能通过索引删除，只能通过对象删除；成功删除返回true，失败返回false
boolean contains(OBJect obj)//查 根据equals进行判断是否存在 如果集合中存储对是自定义对象，则需要重写equals方法  另外字符串比较也是equals。
void clear() 
boolean isEmpty()
int size()

迭代器遍历时候，不可以使用集合的方法进行增加删除。可以使用迭代器提供的remove方法删除。

Iterator<String> it=coll.iterator();
while(it.hasNext()){
    String str=it.next();//next方法获取元素，并移动指针。
    if("bbb".equals(str)){
        //coll.remove("bbb");
        it.remove();
    }
}

List

定义：有序，可重复，有索引（存取有序）

boolean add(int index,E e)//增
boolean remove(E e)//删，可以通过索引删除，将被删除的元素返回
boolean set(int index,E e)//改
E get(int index)  //返回指定的元素

额外添加的方法：迭代器可添加元素

ListIterator<String> it=list.listIterator();
while(it.hasNext()){
    String str=it.next();//next方法获取元素，并移动指针。
    if("bbb".equals(str)){
        
        list.add("qqq");
    }
}

另外。增强for循环中s为临时变量

for(String s:list){
	s="q";
}
image-20241125205428043

LinkedList

底层数据是双链表，查询慢，增删快，操作首尾也很快。

image-20241125211420546

Vector

Set

定义：无序，不重复，无索引

boolean add(E e)//增，不可重复，若添加重复返回值为false
boolean remove(E e)//删
boolean contains(OBJect obj)//查
void clear() 
boolean isEmpty()
int size()    

Set<String> s=new HashSet<>();
s.add("wang");
s.add("quqi");
s.add("wang");

Iterator<String> it=s.iterator();
while(it.hasNext()){
    String str=it.next();
    System.out.println(str);
}
for(String str:s)
{
   System.out.println(str);
}

HashSet

底层采用hash表储存。

一般情况下会重写hashCode方法，不同对象只要属性值相同，哈希值就一样。如果没有重写则不同。

如果集合中存储的是自定义对象，必须重写hashCode和equals方法

HashSet<Student> hs=new HashSet<>();

TreeSet

不重复，无索引，可排序（从小到大：数值类型，字符，字符串ASCII码表）

基于红黑树实现。

如何比较自定义？

  1. 默认的排序规则 Student实现Comparable接口，重写里面的抽象方法。
public class Student implements Comparable<Student>{
    
public int compareTo(Student o) {
    //指定排序规则
    return this.getAge()-o.getAge();//年龄升序
//this表示要添加的元素，o表示红黑树存在的元素。 返回值为负，说明添加元素是小的，在左边，为正，元素是大的，存右边。
}
    
}
  1. 比较器排序：创建TreeSet对象时候，传递比较器Comparator指定规则。
 TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int i = o1.getName().length() - o2.getName().length();//按照长度排序
                i = i == 0 ? o1.compareTo(o2) : i;				      //如果一样长按照首字母排序。（如果长度为0，按照默认比较规则排序）
                return i;											  //如果长度不为0，按照上面相减为准。
            }
        });
image-20241126205256395

Map（双列集合）

键和值一一对应，键不可重复，值可以重复。

键值对叫做Entry对象。

V put(K key,V value)//增   如果键不存在，直接把键值对对象加入map集合。如果键存在，把原有的键值对对象覆盖，被覆盖的值返回。
V remove(Object key)//删    成功删除返回被删除的值。
boolean containsKey(Object key)//查
boolean containsValue(Obkect value)//查
void clear()
boolean isEmpty()
int size()

Map遍历方法

键找值 ：

map.keySet(); set集合包含key对象

map.get(key)

Map<String,String> map=new HashMap<>();

map.put("曲奇","安子");
map.put("安子","曲奇");

Set<String> keys=map.keySet();//获取所有的对象，把键放到一个集合中。
       for (String key : keys) {
           System.out.println(key);
           String value=map.get(key);//get查找键对应的值
           System.out.println(key+"=" +value);
       }

Iterator<String> it=keys.iterator();
       while(it.hasNext())
       {
           String str=it.next();
           String value=map.get(str);
           System.out.println(str+"="+value);
       }

键值对

map.entrySet();set集合包含Entry对象 ctrl alt v自动补全代码

entry.getKey();

entry.getValue();

Set<Map.Entry<String, String>> entries = map.entrySet();//通过方法获得所有键值对象，返回set集合

 for(Map.Entry<String, String> entry:entries){//遍历集合，获得所有键值对对象
            String key=entry.getKey();
            String value=entry.getValue();//利用entry调用get
            System.out.println(key+"="+value);
        }

 Iterator<Map.Entry<String, String>> iterator = entries.iterator();
        while(iterator.hasNext())
        {
            Map.Entry<String, String> entry = iterator.next();
            String key=entry.getKey();
            String value=entry.getValue();
            System.out.println(key+"="+value);

        }

HashMap

不重复，无索引，无序。

底层和hashSet完全一样，哈希表结构（长度为16，默认加载因子为0.75的数组）

利用键计算哈希值。

如果键存储为自定义对象，需要重写hashCode和equals方法。值不需要。

底层原理

TreeMap

不重复，无索引，可排序（默认/自定义）

和TreeSet底层原理一样，都是红黑树结构。

TreeMap<Integer, String> tm = new TreeMap<>();//打出new TreeMap使用ctrl alt v
TreeMap<Integer, String> tm = new TreeMap<>(new Comparator<Integer>() {//ctrl+p 查看形参，new comparator补齐
           @Override
           public int compare(Integer o1, Integer o2) {
               return 0;
           }
       });

如何比较自定义？

  1. 默认的排序规则 Student实现Comparable接口，重写里面的抽象方法。
  2. 比较器排序：创建TreeSet对象时候，传递比较器Comparator指定规则。

例子：统计字符串中每个字符出现个数。

String s="aacdbbdc";

TreeMap<Character,Integer> tm=new TreeMap<>();
for(int i=0;i<s.length();i++)
{
    char c=s.charAt(i);

    if(tm.containsKey(c)){
       int count=tm.get(c);
       count++;
       tm.put(c,count);
    }else{
        tm.put(c,1);
    }
}
System.out.println(tm);

可变参数

方法形参的个数可以发生变化，格式：属性类型 ...名字//int...args

在方法中，其他形参放在前面，可变参数写在最后

public static int getSum(int...args){

}

泛型

泛型不能写基本数据类型，要写必须写其包装类。如数字：Integer。

指定泛型类型后，传递数据时可以传入子类类型。

如果不写类型则默认为Object类。

public static void main(String[] args) {
    ObjectBox objectBox=new ObjectBox();//box对象
    Apple apple=new Apple();//苹果对象
    objectBox.setContent(apple);//添加苹果

    Apple content= (Apple) objectBox.getContent();//取出对象为object类，需要强制转换为apple类
}

public class ObjectBox {
    private Object content;//Object类

    public Object getContent() {
        return content;
    }

    public void setContent(Object content) {
        this.content = content;
    }
}

取出对象为object类，需要强制转换为apple类.

泛型类

通过泛型类可以直接获得

public class GenericBox<T> {//泛型T
    private T content;

    public T getContent() {
        return content;
    }

    public void setContent(T content) {
        this.content = content;
    }
}

GenericBox<Apple> genericBox=new GenericBox<>();//泛型apple
Apple apple=new Apple();
genericBox.setContent(apple);

Apple content= genericBox.getContent();//直接获得apple类

泛型方法

要定义泛型方法，请将泛型类型参数放在返回值之前

public static <T> void printArray(T[] x)
{
    for(T ele:x)
    {
        System.out.println(ele);
    }
}

Apple[] apples=new Apple[2];
printArray(apples);

泛型通配符

泛型不可以继承，但是泛型的数据可以继承。

ArrayList<Ye> list1=new ArrayList<>();
ArrayList<Fu> list2=new ArrayList<>();
ArrayList<Zi> list3=new ArrayList<>();
list.add(new Ye());//dui

method(list1);//泛型里面写什么类型，只能传递什么类型数据（public static void method(ArrayList<Ye> list)）
method(list2);
method(list3);

通配符：？ 进行类型限定

<？extends E> 表示可以传递E和所有子类

<？ super E> 表示传递E和所有父类

工具类

定义

工具类是为了提供一些通用的、某一非业务领域内的公共方法，仅仅是作为工具方法被使用。所以将它做成静态方法最合适，不需要实例化。

如果要实例化一个工具类，就需要一定的内存空间，工具类提供的是静态方法，通过类就能调用，所以不必浪费内存去实例化工具类对象。

public final class Math {  
    /**  
     * Don't let anyone instantiate this class.  
     */  
    private Math() {}  
}

设置构造函数为private访问权限，表示除了类本身外，谁都不能产生一个实例，因此，其他类只能通过类名来访问，不能通过实例对象访问。而由于工具类中都提供静态方法，所以可以通过类进行访问。

Collections

是集合的工具类。

addAll(Collection<T> c,T...elements)  //批量参加元素
shuffle(List<?>list)//打乱顺序    
sort(List<T> list)
sort(List<T> list,Comparator<T> c)
copy(List<T>dest,List<T>src)//拷贝

红黑树

posted @ 2024-11-29 10:53  cookiesDing  阅读(34)  评论(0)    收藏  举报