Java集合类

Collection接口是构造集合框架的基础，定义了操作对象集合的共同方法。 List接口是有序，可包含重复元素的列表。 Set接口是无序的，无重复元素的集合的列表。

package com.collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
public class CollectionTest1 { 
    public static void main(String[] args) { 
        //有序，重复，有索引
        Collection c=new ArrayList();
        c.add("a");
        c.add("a");
        c.add("b");
        c.add("c");
        c.add("d");
        c.add("d");
        System.out.println(c);  //[a, a, b, c, d, d]
        //无序，不重复，无索引
        Collection c1=new HashSet();
        c1.add("a");
        c1.add("a");
        c1.add("b");
        c1.add("c");
        c1.add("d");
        c1.add("d");
        System.out.println(c1);  //[a, b, c, d]

    }
}

案例：

package com.collection;

import java.util.ArrayList;
import java.util.Collection;

public class Collection_API { 
    public static void main(String[] args) { 
        Collection<String> c=new ArrayList<>();
        //添加元素
        c.add("小马哥");
        c.add("小飞侠");
        c.add("罗西");
        c.add("马奎斯");
        c.add("罗西");
        System.out.println(c);  //[小马哥, 小飞侠, 罗西, 马奎斯, 罗西]
        //获取集合大小
        System.out.println(c.size());  //5
        //判断集合是否为空
        System.out.println(c.isEmpty());  //false
       // System.out.println(c);
        //判断集合中是否包含某个元素
        System.out.println(c.contains("小马哥"));  //true
        //删除某个元素，如果是重复元素，则删除第一个
        System.out.println(c.remove("罗西"));  //true
        System.out.println(c);  //[小马哥, 小飞侠, 马奎斯, 罗西]
        //把集合转换为数组
        Object o=c.toString();
        System.out.println(o);  //[小马哥, 小飞侠, 马奎斯, 罗西]
        //清空集合元素
        c.clear();
        System.out.println(c);   //[]
        //将集合c2中的元素倒入c1中
        Collection<String> c1=new ArrayList<>();
        c1.add("a");
        c1.add("b");
        c1.add("c");
        Collection<String> c2=new ArrayList<>();
        c2.add("d");
        c2.add("e");
        c2.add("f");
        c2.add("g");
        c1.addAll(c2);
        System.out.println(c1);  //[a, b, c, d, e, f, g]


    }
}

1.Iterator迭代器

案例：

package com.collection.iterator;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

//collection集合遍历方式
public class IteratorTest { 
    public static void main(String[] args) { 
        //iterator遍历
        //创建Collection集合对象
        Collection<String> c=new ArrayList<>();
        //添加元素
        c.add("小马哥");
        c.add("小飞侠");
        c.add("罗西");
        c.add("马奎斯");
        c.add("罗西");
       //得到迭代器对象
        Iterator<String> it = c.iterator();
        //循环遍历
        while (it.hasNext()){ 
            System.out.println(it.next());
        }
    }
}
/* 小马哥 小飞侠 罗西 马奎斯 罗西 */

2.增强for循环遍历

案例：

package com.collection;

import java.util.ArrayList;
import java.util.Collection;

//增强for遍历
public class ForTest { 
    public static void main(String[] args) { 
        Collection<String> c=new ArrayList<>();
        //添加元素
        c.add("小马哥");
        c.add("小飞侠");
        c.add("罗西");
        c.add("马奎斯");
        c.add("罗西");
        for (String s : c) { 
            System.out.println(s);
        }
    }
}
/* 小马哥 小飞侠 罗西 马奎斯 罗西 */

3.案例分析

package com.collection.Test;

public class Student { 
    private String name;
    private int age;
    private double height;

    public Student() { 
    }

    public Student(String name, int age, double height) { 
        this.name = name;
        this.age = age;
        this.height = height;
    }

    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;
    }

    public double getHeight() { 
        return height;
    }

    public void setHeight(double height) { 
        this.height = height;
    }

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


package com.collection.Test;

import java.util.ArrayList;
import java.util.Collection;

public class StudentTest { 
    public static void main(String[] args) { 
        Collection<Student> students=new ArrayList<>();
        students.add(new Student("小马哥",34,180.5));
        students.add(new Student("小飞侠",44,170.5));
        students.add(new Student("马奎斯",24,190.5));
        students.add(new Student("罗西",54,189.5));
        for (Student student : students) { 
            System.out.println(student.getName()+"\t"+student.getAge()+"\t"+student.getHeight());
        }
    }
}
/* 小马哥 34 180.5 小飞侠 44 170.5 马奎斯 24 190.5 罗西 54 189.5 */

1.Arraylist类

案例：

package com.list;

import java.util.ArrayList;
import java.util.List;

public class ListTest { 
    public static void main(String[] args) { 
        //创建一个List集合对象
        List<String> list=new ArrayList();
        list.add("小马哥");
        list.add("小飞侠");
        list.add("马奎斯");
        list.add("小马哥");
        //在某个索引插入元素
        list.add(1,"罗西");
        System.out.println(list);  //[小马哥, 罗西, 小飞侠, 马奎斯, 小马哥]
        //根据索引删除元素
        list.remove(1);
        System.out.println(list);  //[小马哥, 小飞侠, 马奎斯, 小马哥]
        //根据索引获取元素
        System.out.println(list.get(2));   //马奎斯
        //修改某索引的元素
        list.set(1,"科比");
        System.out.println(list);  //[小马哥, 科比, 马奎斯, 小马哥]
    }
}

2.List遍历方式

package com.list;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

//List遍历方式
public class ListTest2 { 
    public static void main(String[] args) { 
        List<String> list=new ArrayList();
        list.add("小马哥");
        list.add("小飞侠");
        list.add("马奎斯");
        list.add("小马哥");
        //for循环
        for (int i = 0; i <list.size() ; i++) { 
            String s = list.get(i);
            System.out.println(s);
        }
        System.out.println();
        //iterator迭代器
        Iterator<String> it = list.iterator();
        while (it.hasNext()){ 
            String s = it.next();
            System.out.println(s);
        }
        System.out.println();
        //增强for循环
        for (String s : list) { 
            System.out.println(s);
        }

    }
}
/* 小马哥 小飞侠 马奎斯 小马哥 小马哥 小飞侠 马奎斯 小马哥 小马哥 小飞侠 马奎斯 小马哥 */

3.List遍历删除相同元素

package com.list;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

//遍历删除相同元素
public class ListTest3 { 
    public static void main(String[] args) { 
        List<String> list=new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        System.out.println(list);  //[a, b, b, c, d, e]
        //迭代器删除元素
       /* Iterator<String> it = list.iterator(); while (it.hasNext()){ String s = it.next(); if ("b".equals(s)){ it.remove(); //使用迭代器删除保证不后移 } } System.out.println(list); //[a, c, d, e]*/

       //for循环删除元素(方式一)
        /*for (int i = 0; i <list.size() ; i++) { String s = list.get(i); if ("b".equals(s)){ list.remove("b"); i--; } } System.out.println(list); //[a, c, d, e]*/

        //for循环删除元素(方式二)
        for (int i =list.size()-1; i >=0 ; i--) { 
            String s = list.get(i);
            if ("b".equals(s)){ 
                list.remove("b");
            }

        }
        System.out.println(list);  //[a, c, d, e]

    }
}

4.LinkedList类

package com.list;

import java.util.LinkedList;

public class LinkedListTest { 
    public static void main(String[] args) { 
        //LinkedList可以完成队列结构和栈结构
        //栈
        LinkedList<String> ll=new LinkedList<>();
        //入栈
        ll.addFirst("第一块积木");
        ll.addFirst("第二块积木");
        ll.addFirst("第三块积木");
        ll.addFirst("第四块积木");
        ll.addFirst("第五块积木");
        System.out.println(ll);
        //出栈
        System.out.println(ll.removeFirst());
        System.out.println(ll.removeFirst());
        System.out.println(ll.removeFirst());
        System.out.println(ll.removeFirst());
        System.out.println(ll);
        /* [第五块积木, 第四块积木, 第三块积木, 第二块积木, 第一块积木] 第五块积木 第四块积木 第三块积木 第二块积木 [第一块积木] */

        //队列
        LinkedList<String> ll1=new LinkedList<>();
        //入队
        ll1.addLast("1");
        ll1.addLast("2");
        ll1.addLast("3");
        ll1.addLast("4");
        ll1.addLast("5");
        System.out.println(ll1);
        //出队
        System.out.println(ll1.removeLast());
        System.out.println(ll1.removeLast());
        System.out.println(ll1.removeLast());
        System.out.println(ll1.removeLast());
        System.out.println(ll1);
/* [1, 2, 3, 4, 5] 5 4 3 2 [1] */

    }
}

1.HashSet类

package com.set.hashSet;

import java.util.HashSet;
import java.util.Set;

public class Test1 { 
    public static void main(String[] args) { 
        Set<String> sets=new HashSet<>();
        sets.add("小马哥");
        sets.add("小飞侠");
        sets.add("马奎斯");
        sets.add("罗西");
        System.out.println(sets);  //[马奎斯, 小马哥, 罗西, 小飞侠]

    }
}

案例：

package com.set.hashSet;

public class Student { 
    private String name;
    private int age;
    private char sex;

    public Student() { 
    }

    public Student(String name, int age, char sex) { 
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    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;
    }

    public char getSex() { 
        return sex;
    }

    public void setSex(char sex) { 
        this.sex = sex;
    }

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

        Student student = (Student) o;

        if (age != student.age) return false;
        if (sex != student.sex) return false;
        return name.equals(student.name);
    }

    @Override
    public int hashCode() { 
        int result = name.hashCode();
        result = 31 * result + age;
        result = 31 * result + (int) sex;
        return result;
    }

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


package com.set.hashSet;

import java.util.HashSet;
import java.util.Set;

public class StudentTest { 
    public static void main(String[] args) { 
        Set<Student> sets=new HashSet<>();
        sets.add(new Student("小马哥",34,'男'));
        sets.add(new Student("小马哥",34,'男'));
        sets.add(new Student("小飞侠",24,'女'));
        System.out.println(sets);  //[Student{name='小飞侠', age=24, sex=女}, Student{name='小马哥', age=34, sex=男}]

    }
}

注意：

2.TreeSet类

package com.set.TreeSet;

import java.util.Set;
import java.util.TreeSet;

public class Test1 { 
    public static void main(String[] args) { 
        Set<Integer> s1=new TreeSet<>();  //无序，不重复，可排序
        s1.add(21);
        s1.add(12);
        s1.add(12);
        s1.add(1);
        s1.add(56);
        s1.add(45);
        System.out.println(s1);  //[1, 12, 21, 45, 56]

        Set<String> s2=new TreeSet<>();  无序，不重复，可排序
        s2.add("小马哥");
        s2.add("A");
        s2.add("Z");
        s2.add("D");
        s2.add("z");
        s2.add("a");
        System.out.println(s2);  //[A, D, Z, a, z, 小马哥]

    }
}

1.自然排序和比较器排序

案例：

package com.set.TreeSet;

public class Student implements Comparable<Student> { 
    private String name;
    private int age;
    private double score;

    public Student(String name) { 
        this.name = name;
    }

    public Student(String name, int age, double score) { 
        this.name = name;
        this.age = age;
        this.score = score;
    }

    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;
    }

    public double getScore() { 
        return score;
    }

    public void setScore(double score) { 
        this.score = score;
    }

    @Override
    public String toString() { 
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
//第一种类定义比较规则
    @Override
    public int compareTo(Student o) { 
        //按照年龄排序
        //return this.getAge()-o.getAge(); //去掉了年龄相同的元素
        //[Student{name='小马哥', age=23, score=99.9}, Student{name='马奎斯', age=34, score=70.9}, Student{name='罗西', age=44, score=85.5}]
        return this.getAge()-o.getAge()>=0?1:-1;  //保留了年龄相同的元素
        //[Student{name='小马哥', age=23, score=99.9}, Student{name='小飞侠', age=23, score=89.5}, Student{name='马奎斯', age=34, score=70.9}, Student{name='罗西', age=44, score=85.5}]
    }
}


package com.set.TreeSet;

import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

public class StudentTest { 
    public static void main(String[] args) { 
        //集合自带比较器对象进行规则制定
        Set<Student> s=new TreeSet<>(new Comparator<Student>() { 
            @Override
            public int compare(Student o1, Student o2) { 
               // return (int) (o1.getScore()-o2.getScore()); //升序
                return (int) (o2.getScore()-o1.getScore());  //降序
                //[Student{name='小马哥', age=23, score=99.9}, Student{name='小飞侠', age=23, score=89.5}, Student{name='罗西', age=44, score=85.5}, Student{name='马奎斯', age=34, score=70.9}]
            }
        });
        s.add(new Student("小马哥",23,99.9));
        s.add(new Student("小飞侠",23,89.5));
        s.add(new Student("马奎斯",34,70.9));
        s.add(new Student("罗西",44,85.5));
        System.out.println(s);

    }
}

注意：

package com.params;

import java.util.Arrays;

public class Test { 
    public static void main(String[] args) { 
        //不传参数
        //sum();
        //可以传一个参数
        sum(12);
        //可以传多个参数
        sum(23,34,45);
        //可以传一个数组
        //sum(new int[]{12,23,34,45});

    }
    public static void sum(int age,int ... num){ 
        System.out.println("元素个数："+num.length);
        System.out.println("元素内容："+ Arrays.toString(num));

    }
}
/* 元素个数：0 元素内容：[] 元素个数：1 元素内容：[12] 元素个数：3 元素内容：[23, 34, 45] 元素个数：4 元素内容：[12, 23, 34, 45] */

案例：

package com.collection.collections;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Test { 
    public static void main(String[] args) { 
        List<String> list=new ArrayList<>();
        /*list.add("小马哥"); list.add("小飞侠"); list.add("马奎斯"); list.add("罗西");*/

        //批量添加元素
        Collections.addAll(list,"小马哥","小飞侠","马奎斯","罗西");  //[小马哥, 小飞侠, 马奎斯, 罗西]
        System.out.println(list);
        //打乱集合顺序
        Collections.shuffle(list);
        System.out.println(list);  //[马奎斯, 小飞侠, 罗西, 小马哥]
        //将集合中元素按默认规则排序
        List<Integer> l=new ArrayList<>();
        Collections.addAll(l,12,34,23,78,99,35);
        Collections.sort(l);
        System.out.println(l);  //[12, 23, 34, 35, 78, 99]
        //将集合中元素按指定规则排序
    }
}

1.Map集合概述

案例：

package com.map;
import java.util.HashMap;
import java.util.Map;
public class Test { 
    public static void main(String[] args) { 
        Map<String,Integer> m=new HashMap<>();
        m.put("小马哥",33);
        m.put("小飞侠",44);
        m.put("马奎斯",33);
        m.put("罗西",45);
        m.put(null,null);
        System.out.println(m);  //{null=null, 马奎斯=33, 小马哥=33, 罗西=45, 小飞侠=44}

    }
}

2.Map集合API

案例：

package com.map;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Test1 { 
    public static void main(String[] args) { 
        //创建Map集合
        Map<String,Integer> m=new HashMap<>();
        //添加元素
        m.put("小马哥",33);
        m.put("小飞侠",44);
        m.put("马奎斯",33);
        m.put("罗西",45);
        //清空集合
        //m.clear();
        //System.out.println(m); //{}
        //判断集合是否为空
        System.out.println(m.isEmpty());  //false
        //根据键获取对应的值
        Integer i = m.get("小马哥");
        System.out.println(i);  //33
        //根据键删除整个元素
        System.out.println(m.remove("小马哥"));  //33
        System.out.println(m);  //{马奎斯=33, 罗西=45, 小飞侠=44}
        //判断是否包含某个键
        System.out.println(m.containsKey("罗西")); //true
        System.out.println(m.containsKey("小马哥"));  //false
        //判断是否包含某个值
        System.out.println(m.containsValue(45));  //true
        //获取全部键的集合
        Set<String> keySet = m.keySet();
        System.out.println(keySet);  //[马奎斯, 罗西, 小飞侠]
        //获取全部值的集合
        Collection<Integer> values = m.values();
        System.out.println(values);  //[33, 45, 44]
        //集合的大小
        System.out.println(m.size());  //3
        //合并其他Map集合
        Map<String,Integer> m1=new HashMap<>();
        m1.put("a",1);
        m1.put("b",2);
        Map<String,Integer> m2=new HashMap<>();
        m1.put("c",3);
        m1.put("d",4);
        m1.putAll(m2);  //把m2中的元素合并到m1中
        System.out.println(m1);   //{a=1, b=2, c=3, d=4}


    }
}

3.Map集合遍历方式

1.键找值

案例：

package com.map;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Test2 { 
    public static void main(String[] args) { 
        Map<String,Integer> m=new HashMap<>();
        //添加元素
        m.put("小马哥",33);
        m.put("小飞侠",44);
        m.put("马奎斯",33);
        m.put("罗西",45);
        //键找值
        //先获取所有的键
        Set<String> keys = m.keySet();
        for (String key : keys) { 
            Integer values = m.get(key);
            System.out.println(key+"="+values);
        }
    }
}
/* 马奎斯=33 小马哥=33 罗西=45 小飞侠=44 */

2.键值对

案例：

package com.map;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Test3 { 
    public static void main(String[] args) { 
        Map<String,Integer> m=new HashMap<>();
        //添加元素
        m.put("小马哥",33);
        m.put("小飞侠",44);
        m.put("马奎斯",33);
        m.put("罗西",45);
        //把Map集合转换为set集合
        Set<Map.Entry<String, Integer>> entries = m.entrySet();
        //for遍历
        for (Map.Entry<String, Integer> entry : entries) { 
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key+"="+value);
        }

    }
}
/* 马奎斯=33 小马哥=33 罗西=45 小飞侠=44 */

注意：

本文为互联网自动采集或经作者授权后发布，本文观点不代表立场，若侵权下架请联系我们删帖处理！文章出自：https://blog.csdn.net/qq_43514330/article/details/125147390

Java集合类

1.Iterator迭代器

2.增强for循环遍历

3.案例分析

1.Arraylist类

2.List遍历方式

3.List遍历删除相同元素

4.LinkedList类

1.HashSet类

2.TreeSet类

1.自然排序和比较器排序

1.Map集合概述

2.Map集合API

3.Map集合遍历方式

1.键找值

2.键值对

相关推荐

BUUCTF Web [极客大挑战 2019]Knife

BUUCTF Web [强网杯 2019]随便注

env: php: No such file or directory Mac 12系统解决办法

大白话讲解JDK源码系列：从头到尾再讲一遍ThreadLocal

发表评论

热门文章

标签TAG

# java

# 安全

# 网络安全

# WEB安全

# 渗透测试

# 开发语言

# 信息安全

# linux

# 安全漏洞

# python

# Spring

# c语言

# 网络

# 后端

最近回复