Java-----集合（3）_java list<object>元素个数函数-CSDN博客

本文链接：https://blog.csdn.net/kukudeYSB/article/details/123884926

List中的一些方法：

import java.awt.*;
import java.util.*;
import java.util.List;

public class ListTest
{
    public static void main(String[] args)
    {
        ArrayList List = new ArrayList();
        List.add(123);
        List.add(456);
        List.add("Tom");
        List.add(false);
        System.out.println(List);


        //void add(int index,Object ele);在index位置插入ele元素
        List.add(0,"BB");
        System.out.println(List);


        //boolead addAll(int index,Collection eles);从index位置开始将eles中的所有元素添加
        java.util.List<Integer> List2 = Arrays.asList(1,2,3);
        List.addAll(List2);
        System.out.println(List);
        System.out.println(List.size());


        //Object get(int index);获取指定index位置的元素
        System.out.println(List.get(1));


        //int indexOf(Object obj);返回obj在当前集合中首次出现的位置
        int index = List.indexOf(123);
        System.out.println(index);//存在返回index位置
        int index1 = List.indexOf("BBB");
        System.out.println(index1);//不存在返回-1


        //int lastIndexOf(Objject obj);返回obj在当前集合中末次出现的位置.是否存在的返回结果与indexOf();相同
        List.add(123);
        System.out.println(List.lastIndexOf(123));


        //Object remove(int index);移除指定index位置的元素，并返回此元素
        List.remove(1);
        System.out.println(List);

        //Object set(int index,Object ele);设置指定index位置的元素为ele
        List.set(0,"CC");
        System.out.println(List);

        //List sublist(int fromIndex, int toIndex);返回从FromIndex到toIndex位置的左闭右开的子集合
        List sublist = List.subList(1,3);//左闭右开
        System.out.println(sublist);
    }
}

结果：

常用方法：

增：add(Object obj);

删：remove(int index); / remove(Object obj);

改：set(int index , Object obj);

查：get(int index);

插：add(int index , Object ele);

长度：size();

遍历：1、Iterator迭代器 2、增强for循环 3、普通的循环

区分 List 中 remove(int index) 和 remove(Object obj):

List.remove(2);//删除index位置上的元素

List.remove( new Integer(2) );//删除这个元素

Set接口：存储无序的、不重复的数据

HashSet：作为Set接口的主要实现类；线程不安全的；可以储存null值

LinkHashSet：作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历

TreeSet：可以按照添加的对象的指定属性，进行排序

添加元素的过程：以HashSet为例：

LinkedHashSet的使用：

LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录次数据前一个数据和后一个数据。

优点：对于频繁的遍历操作，LinkedHashSet效率高于HashSet

TreeSet的使用：

自然排序：

Set：

import java.util.*;

public class Set
{
    public static void main(String[] args)
    {
        TreeSet set = new TreeSet();
        set.add(new Person("Ben",18));
        set.add(new Person("Jerry",20));
        set.add(new Person("Bob",22));
        set.add(new Person("Alan",30));
        set.add(new Person("Alan",33));

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

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 int getAge()
    {
        return age;
    }

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

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

    //按照名字从小到大排序，年龄从小到大排序
    public int compareTo(Object o)
    {
        if(o instanceof Person)
        {
            Person p = (Person) o;
//            return this.name.compareTo(p.name);
            int compare = this.name.compareTo(p.name);
            if(compare != 0)
            {
                return compare;
            }
            else
            {
                return Integer.compare(this.age,p.age);
            }
        }
        else
        {
            throw new RuntimeException("输入的类型不匹配");
        }
    }
}

结果：

定制排序：

Set：(Person相同)

import javax.swing.*;
import java.util.*;

public class Set
{
    public static void main(String[] args)
    {
        Comparator com = new Comparator(){
            //按照年龄从小到大排序
            @Override
            public int compare(Object o1,Object o2) {
                if(o1 instanceof Person && o2 instanceof  Person)
                {
                    Person u1 = (Person)o1;
                    Person u2 = (Person)o2;
                    return Integer.compare(u1.getAge(),u2.getAge());
                }
                else
                {
                    throw new RuntimeException("输入的数据类型不匹配");
                }
            }
        };


        TreeSet set = new TreeSet(com);
        set.add(new Person("Ben",18));
        set.add(new Person("Jerry",20));
        set.add(new Person("Bob",22));
        set.add(new Person("Alan",30));
        set.add(new Person("Alan",33));

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

结果：

Map接口：

Map的实现类的结构：

Map结构的理解：

Map中定义的方法：

添加、删除、修改操作：

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

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

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

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

import java.util.HashMap;

public class Map
{
    public static void main(String[] args)
    {
        HashMap map = new HashMap();
        //添加
        map.put("AA",123);
        map.put("45",123);
        map.put("BB",123);
        map.put("67",123);
        System.out.println(map);
        //修改
        map.put("AA",456);
        System.out.println(map);

        HashMap map1 = new HashMap();
        map1.put("CC",123);
        map1.put("DD",123);
        map.putAll(map1);
        System.out.println(map);

        //remove(Object key);根据key移除
        Object value = map.remove("CC");
        System.out.println(value);
        System.out.println(map);

        //clear();清空元素
        map.clear();//与map = null; 不同
        System.out.println(map.size());
    }
}

结果：

元素查询的操作：

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

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

boolean containsValue(Object value);是否包含指定的value

int size();返回map中key-value对的个数

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

boolean equals(Object obj);判断当前map和参数对象obj是否相等

import java.util.HashMap;

public class Map
{
    public static void main(String[] args)
    {
        HashMap map = new HashMap();
        //添加
        map.put("AA",123);
        map.put(45,123);
        map.put("BB",123);
        map.put(67,123);
        System.out.println(map);

        //Object get(Object key);
        System.out.println(map.get(45));

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

        //containsValue(Object value);
        isExist = map.containsValue(123);
        System.out.println(isExist);

        //int size();
        int size = map.size();
        System.out.println(size);

        //boolean isEmpty();
        isExist = map.isEmpty();
        System.out.println(isExist);
        map.clear();
        isExist = map.isEmpty();
        System.out.println(isExist);

        //boolean equals(Object o);
        HashMap map1 = new HashMap();
        map1.put(123,123);
        isExist = map.equals(map1);
        System.out.println(isExist);
        System.out.println(map1);
    }
}

结果：

元视图操作的方法：

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

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

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

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

public class Map
{
    public static void main(String[] args)
    {
        HashMap map = new HashMap();
        //添加
        map.put("AA",123);
        map.put(45,123);
        map.put("BB",123);
        map.put(67,123);
        System.out.println(map);

        //遍历所有的key集:keySet();
        Set set = map.keySet();
        Iterator iterator = set.iterator();
        while (iterator.hasNext())
        {
            System.out.println(iterator.next());
        }

        //遍历所有的value集:values();
        Collection values = map.values();
        for (Object value : values) {
            System.out.println(value);
        }
        System.out.println();

        //遍历所有的key-value
        //entrySet();
        Set entrySet = map.entrySet();
        Iterator iterator1 = entrySet.iterator();
        while(iterator1.hasNext())
        {
            //System.out.println(iterator1.next());
            Object obj = iterator1.next();
            //entrySet集合中的元素都是entry
            HashMap.Entry entry = (HashMap.Entry) obj;
            System.out.println(entry.getKey() + "---->" + entry.getValue());
        }
    }
}

结果：

TreeMap：

向TreeMap中添加key-value，要求key必须是由同一个类创造的对象：
自然排序：

import java.util.Iterator;
import java.util.Set;
import java.util.TreeMap;

public class Map
{
    public static void main(String[] args)
    {
        TreeMap map = new TreeMap();

        Person p1 = new Person("Jack",22);
        Person p2 = new Person("Ben",18);
        Person p3 = new Person("Rose",33);
        Person p4 = new Person("Tom",19);

        map.put(p1,98);
        map.put(p2,100);
        map.put(p3,90);
        map.put(p4,60);

        System.out.println(map);

        //自然排序
        Set set = map.entrySet();
        Iterator iterator = set.iterator();
        while (iterator.hasNext())
        {
            Object obj = iterator.next();
            java.util.Map.Entry entry = (java.util.Map.Entry) obj;
            System.out.println(entry.getKey() + "---->" + entry.getValue());
        }
    }
}

结果：

定制排序：

import java.util.Comparator;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeMap;

public class Map
{
    public static void main(String[] args)
    {
        TreeMap map = new TreeMap(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof Person && o2 instanceof Person)
                {
                    Person p1 = (Person)o1;
                    Person p2 = (Person)o2;
                    return Integer.compare(p1.getAge(),p2.getAge());
                }
                else throw new RuntimeException("输入方式不正确！");
            }
        });

        Person p1 = new Person("Jack",22);
        Person p2 = new Person("Ben",18);
        Person p3 = new Person("Rose",33);
        Person p4 = new Person("Tom",19);

        map.put(p1,98);
        map.put(p2,100);
        map.put(p3,90);
        map.put(p4,60);

        System.out.println(map);

        Set set = map.entrySet();
        Iterator iterator = set.iterator();
        while (iterator.hasNext())
        {
            Object obj = iterator.next();
            java.util.Map.Entry entry = (java.util.Map.Entry) obj;
            System.out.println(entry.getKey() + "---->" + entry.getValue());
        }
    }
}

结果：

Properties:(还需要写一个)

Collections工具类：（查API文件）

Collections.copy:

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Test
{
    private static java.util.Arrays Arrays;

    public static void main(String[] args)
    {
        List list = new ArrayList();
        list.add(123);
        list.add(13);
        list.add(999);
        list.add(23);

        System.out.println(list);

        List dest = Arrays.asList(new Object[list.size()]);
        System.out.println(dest.size());

        Collections.copy(dest,list);
        System.out.println(dest);

        //System.out.println(list);
    }
}

结果：