JavaSE基础之集合

最新推荐文章于 2024-09-10 10:21:38 发布

尒忸姺泩

最新推荐文章于 2024-09-10 10:21:38 发布

阅读量41

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_46106562/article/details/119281091

版权

Java中的集合两个接口:Collection、Map

Collection	List	ArrayList类
		LinkedList类
	Set	HashSet类
		SoredSet	TreeSet类
Map	HashMap类
	SortMap	TreeMap类

1.Collection

        // 创建集合
        Collection list = new ArrayList();

        // add添加元素
        // 自动封装成Integer
        list.add(1);
        list.add(102);
        list.add(103);
        System.out.println(list.size());// size():集合中元素个数
        System.out.println(list.isEmpty());// isEmpty():判断集合是否为空

        // toArry():把集合转为数组
        Object[] obj = list.toArray();
        for (Object object : obj) {
            System.out.println(object);
        }

        // remove():移除某个元素
        boolean flag1 = list.remove(102);
        // contains():是否包含某个元素
        boolean flag2 = list.contains(1);

        // clear():清空集合
        list.clear();

Iterator迭代器:

语法:

Iterator iterator=集合对象名.iterator();//调用集合对象自己的Iterator()就能创建这个集合的迭代器

常见方法:

        Collection list = new ArrayList();

        list.add(1);
        list.add(10);
        list.add(12);

        /**
         * 迭代器一旦创建,集合中不能添加或删除元素,如果添加和删除了集合中的元素,需要重新生成迭代器
         * 
         * 但是更改里面的数据 不用重新生成
         */
        // 创建迭代器
        Iterator it = list.iterator();
        // 1.hasNext():判断当前游标的下一位是否有元素,常用于循环遍历
        while (it.hasNext()) {
            // next():将迭代器的游标向下移动一位,并返回这个数据
            Object obj = it.next();
            System.out.println(obj);
        }
        // 删除当前游标指向的元素
        // it.remove();

a.List集合:

特点:元素有序可重复,且存入顺序和取出顺序一致

1).ArrayList:底层是数组,并且查询快,增删慢

语法: List<泛型> 集合对象名 = new ArrayList<泛型>();

        
        List list = new ArrayList();
      
        list.add(1);
        list.add("张三");
        list.add(true);

        System.out.println(list);// 会调用集合中每个元素自身的toString方法

        // get(index):获取指定索引对应的元素,等同于 数组名[index] 的方式获取元素
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

        // add(index,"xxx"):把元素插到指定位置(index),原位置数据和原位置之后的数据向后移动一位
        list.add(1, "吃了吗");
        for (Object object : list) {
            System.out.println(object);
        }

        // set(index,"xxx"):用指定的元素内容把指定位置(index)上的元素内容替换
        list.set(2, "吃了");

        Iterator it = list.iterator();
        while (it.hasNext()) {
            Object obj = it.next();
            System.out.println(obj);
        }

        // 将数组转化成List集合的方法
        List<String> str = =Arrays.asList("a","b","c");

对于List集合的排序问题:

如果存入的数据是自定义类,想要对其集合排序,那么该自定义类就必须实现一个Comparable接口,并重写接口中的compareTo方法,再通过Collections.sort(集合对象)进行排序

public class SortList{
    public static void main(String[] args) {
        List list = new ArrayList();
        //添加元素
        list.add(new Dog("admin1", 11));
        list.add(new Dog("admin2", 99));
        list.add(new Dog("admin3", 55));
        list.add(new Dog("admin4", 2));
        

        Collections.sort(list);
        for (Object object : list) {
            System.out.println(object);
        }
    }
}

class Dog implements Comparable<Dog> {//实现Comparable接口
    String name;
    int age;
    
    //覆写接口中的方法:进行升序排序
    @Override
    public int compareTo(Dog o) {
        // 返回值为0:该元素已存在,不插入
        // 返回值大于0:说明要插入的元素值大,往后放
        // 返回值小于0:要添加的元素比集合中的小,往前放
        return this.age - o.age;
    }

    public Dog() {

    }
    public Dog(String name, int age) {
        super();
        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 "Dog [name=" + name + ", age=" + age + "]";
    }


}

2).LinkedList:底层为双向链表,查询慢,增删快

常用方法:

        LinkedList linkList = new LinkedList();
        // add():尾部添加,返回boolean类型
        boolean flag1 = linkList.add(1);
        // addLast():尾部添加
        linkList.addLast(9);
        // push():头部添加
        linkList.push(2);
        // addFirst():头部添加
        linkList.addFirst(7);

        // offerFirst():头部添加,返回boolean类型
        boolean flag2 = linkList.offerFirst(10);
        // offerLast():尾部添加
        boolean flag3 = linkList.offerLast(0);
        // offer():尾部添加
        boolean flag4 = linkList.offer(0);
        // 10,7,2,1,9,0,0
        System.out.println(linkList);

        // get(index):获取指定下标对应的元素
        System.out.println(linkList.get(2));

        // getFirst():获取首位元素
        linkList.getFirst();

        // pop():获取首位元素,并删除该元素,如果没有首位元素(就是集合中元素个数为0 ),会报错
        linkList.pop();

b.Set集合:

特点:元素无序且不可重复

1).HashSet:

语法: Set<泛型> 集合对象名= new HashSet<泛型>();

2).TreeSet:

特点:保存的元素可以按照某种规则自动排序,如数字从大到小、日期以自然日期、字符串以每位的ASCII码值等

注: 关于集合排序:

i.要添加的元素对应的类实现Comparable接口,并实现compareTo()方法

Comparable:叫做元素自身的比较器,就是要添加的元素需要实现这个接口,一般用于自定义类

public class SortedSet{
    public static void main(String[] args) {

        SortedSet ss = new TreeSet();
        ss.add(new User(19));
        ss.add(new User(20));
        ss.add(new User(30));
        ss.add(new User(11));
        System.out.println(ss);
    }
}

class User implements Comparable {//自定义类实现Comparable接口
    int age;

    public User(int age) {
        super();
        this.age = age;
    }

    @Override
    public String toString() {
        return "User [age=" + age + "]";
    }

    @Override
    public int compareTo(Object o) {
        if (!(o instanceof User)) {
            return 0;
        }
        User user = (User) o;
        return this.age - user.age;
    }
}

ii.要添加的元素对应的类实现(比较器类)Comparator接口,并覆写compare()方法

Comparator:比较器类,常用于:源码不可更改,比如Integer是默认升序,我想降序,就需要使用Comparator来重新设置排序,因为它的优先级高

public class SortedSet {
    public static void main(String[] args) {

        SortedSet set = new TreeSet(new ProductComparator());

        set.add(new Products(1.2));
        set.add(new Products(2.0));
        set.add(new Products(0.5));
        set.add(new Products(5.5));

        System.out.println(set);
    }
}

class Products {
    double price;
    public Products(double price) {
        super();
        this.price = price;
    }
    @Override
    public String toString() {
        return "Products [price=" + price + "]";
    }
}

//不更改Products类的前提下进行排序,实现Comparator接口
class ProductComparator implements Comparator {

    @Override
    // o1是要添加的元素
    // o2是集合中的元素
    public int compare(Object o1, Object o2) {      
        double price1 = ((Products) o1).price;
        double price2 = ((Products) o2).price;

        if (price1 == price2) {
            return 0;
        } else if (price1 > price2) {
            return 1;
        }
        return -1;
    }
}

如果对于某个类两种排序都有的话,优先使用compare()方法,因为在运行过程中,先判断有没有compare()方法,如果没有再去执行compareTo()方法

2.Map

a.HashMap

特点:无序可重复,其中可重复指key不可重复,value可以重复

常用方法:(注:Map无法直接进行遍历)

        Map map = new HashMap();

        // put(key,value):添加数据
        map.put("A", 1000);
        map.put('A', 2000);
        map.put(65, 1000);
        map.put("B", "two");
        map.put("C", "three");
        map.put(null, null);

        // size():元素个数
        System.out.println(map.size());
        // remove(key):根据key删除数据
        map.remove(65);

        // get(key):根据key,获取value值
        System.out.println(map.get("B"));

        // values():获取所有value,以集合形式返回
        Collection values = map.values();

        // keySet():获取map中所有key,以set形式返回
        Set keySet = map.keySet();
        for (Object object : keySet) {
            System.out.println(object + ":" + map.get(object));
        }

        // entrySet():把map中的所有entry取出,形成set,并且entry覆写了toString方法,会以    key=value的形式展示
        Set entrySet = map.entrySet();
        for (Object object : entrySet) {
            System.out.println(object);
        }

b.TreeMap:是SortedMap接口的实现类，可以根据Key进行排序

尒忸姺泩

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JavaSE基础之集合

Java中的集合两个接口:Collection、MapCollection List ArrayList类 LinkedList类 Set HashSet类 SoredSet TreeSet类 Map HashMap类 SortMap TreeMap类 1.Collection
复制链接

扫一扫