java esl java es里面的集合添加

转载

码农小哥 2023-05-19 15:52:22

文章标签 javase System java ide 文章分类 Java 后端开发

集合回顾

集合最主要掌握什么内容？

每个集合对象的创建（new）
向集合中添加元素
从集合中取出元素
遍历集合

主要的集合类：

ArrayList
LinkedList
HashSet（HashSet的key、存储在HashMap集合key的元素需要同时重写hashCode + equals方法）
TreeSet
HashMap
Properties
TreeMap

回顾List集合需要掌握什么

package se3.review;

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

/**需要掌握内容：
 * 1. 每个集合对象的创建（new）
 * 2. 向集合中添加元素
 * 3. 从集合中取出元素
 * 4. 遍历集合
 */
public class ArrayListTest {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<String> list = new ArrayList<>();
        //添加元素
        list.add("张三");
        list.add("李四");
        list.add("王五");
        //从集合中取出某个元素。（List集合有下标）
        String firstElt = list.get(0);
        System.out.println(firstElt);//张三
        //遍历:下标方式
        for (int i = 0; i < list.size(); i++) {
            String elt = list.get(i);
            System.out.print(elt + " ");
        }
        System.out.println();
        
        //遍历：迭代器方式（通用的，所有的Collection都能用）
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            System.out.print(it.next() + " ");
        }
        System.out.println();
        
        //遍历：foreach方式
        for (String s : list){
            System.out.print(s + " ");
        }
        /**
         * 以上三种遍历方式输出都是一样的
         * 张三 李四 王五
         */
    }
}

注意：LinkedList掌握内容同上（ArrayList改为LinkedList即可）

回顾HashSet需要掌握什么

package se3.review;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Objects;
import java.util.Set;

/**需要掌握内容：
 * 1. 每个集合对象的创建（new）
 * 2. 向集合中添加元素
 * 3. 从集合中取出元素
 * 4. 遍历集合
 * 5. 测试HashSet集合的特点：无序不可重复
 */
public class HashSetTest {
    public static void main(String[] args) {
        //创建集合对象
        HashSet<String> set = new HashSet<>();
        //添加元素
        set.add("abc");
        set.add("def");
        set.add("king");
        //set集合元素不能通过下标取了（没有下标）
        //遍历：迭代器方式
        Iterator<String> it = set.iterator();
        while (it.hasNext()){
            System.out.print(it.next() + " ");
        }
        System.out.println();

        //foreach方式
        for (String s : set){
            System.out.print(s + " ");
        }
        System.out.println();

        //测试HashSet集合的特点
        set.add("king");
        set.add("king");
        set.add("king");
        System.out.println(set.size());//3(后面3个King都没有加进去)
        set.add("1");
        set.add("10");
        set.add("2");
        for (String s : set){
            System.out.print(s + " ");
        }//1 2 abc def king 10
        System.out.println();

        //创建集合，存储Student数据
        Set<Student> students = new HashSet<>();
        Student s1 = new Student(1,"张三");
        Student s2 = new Student(2,"李四");
        Student s3 = new Student(1,"张三");
        students.add(s1);
        students.add(s2);
        students.add(s3);
        System.out.println(students.size());//2
        //遍历
        for (Student stu : students){
            System.out.println(stu);
        }
        /**
         * 学生{学号=2, 姓名='李四'}
         * 学生{学号=1, 姓名='张三'}
         */
    }
}
class Student{
    int no;
    String name;

    public Student() {
    }

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

    @Override
    public String toString() {
        return "学生{" +
                "学号=" + no +
                ", 姓名='" + name + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return no == student.no &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(no, name);
    }
}

回顾TreeSet需要掌握什么

package se3.review;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

/**需要掌握内容：
 * 1. 每个集合对象的创建（new）
 * 2. 向集合中添加元素
 * 3. 从集合中取出元素
 * 4. 遍历集合
 * 5. 测试TreeSet集合：TreeSet集合中的元素是可排序的，不可重复的
 * 6. 测试TreeSet集合中存储的类型是自定义的
 * 7. 测试实现Comparable接口的方式
 * 8. 测试实现Compa接口的方式（以及匿名内部类的方式）
 */
public class TreeSetTest {
    public static void main(String[] args) {
        //创建集合
        TreeSet<Integer> ts = new TreeSet<>();
        //添加元素
        ts.add(1);
        ts.add(100);
        ts.add(10);
        ts.add(10);
        ts.add(10);
        ts.add(10);
        ts.add(0);
        //遍历(迭代器)
        Iterator<Integer> it = ts.iterator();
        while (it.hasNext()){
            System.out.print(it.next() + " ");
        }//0 1 10 100
        System.out.println();
        //遍历(foreach)
        for (Integer i : ts){
            System.out.print(i + " ");
        }//0 1 10 100
        System.out.println();

        //TreeSet集合中存储自定义类型(第一种方式)
        TreeSet<A> atree = new TreeSet<>();
        atree.add(new A(100));
        atree.add(new A(200));
        atree.add(new A(500));
        atree.add(new A(400));
        atree.add(new A(300));
        atree.add(new A(1000));
        //遍历
        for (A a : atree){
            System.out.print(a + " ");
        }//A{i=100} A{i=200} A{i=300} A{i=400} A{i=500} A{i=1000}
        System.out.println();

        //TreeSet集合中存储自定义类型(第二种方式，比较器)
        TreeSet<B> btree = new TreeSet<>(new BComparator());
        btree.add(new B(500));
        btree.add(new B(100));
        btree.add(new B(200));
        btree.add(new B(600));
        btree.add(new B(300));
        btree.add(new B(50));
        for (B b : btree){
            System.out.print(b + " ");
        }//B{i=50} B{i=100} B{i=200} B{i=300} B{i=500} B{i=600}
        System.out.println();

        //比较器的匿名内部类方式
        TreeSet<C> ctree = new TreeSet<>(new Comparator<C>() {
            @Override
            public int compare(C o1, C o2) {
                return o1.i - o2.i;
            }
        });
        ctree.add(new C(700));
        ctree.add(new C(800));
        ctree.add(new C(200));
        ctree.add(new C(600));
        ctree.add(new C(900));
        ctree.add(new C(90));
        for (C c : ctree){
            System.out.print(c + " ");
        }//C{i=90} C{i=200} C{i=600} C{i=700} C{i=800} C{i=900} 
    }
}//第一种方式：实现Comparable接口
class A implements Comparable<A>{
    int i;

    public A(int i) {
        this.i = i;
    }

    @Override
    public String toString() {
        return "A{" +
                "i=" + i +
                '}';
    }

    @Override
    public int compareTo(A o) {
        return this.i - o.i;
    }
}
//第二种方式：专递比较器
class B {
    int i;

    public B(int i) {
        this.i = i;
    }

    @Override
    public String toString() {
        return "B{" +
                "i=" + i +
                '}';
    }
}
//比较器
class BComparator implements Comparator<B>{

    @Override
    public int compare(B o1, B o2) {
        return o1.i - o2.i;
    }
}

class C {
    int i;

    public C(int i) {
        this.i = i;
    }

    @Override
    public String toString() {
        return "C{" +
                "i=" + i +
                '}';
    }
}

注意：TreeMap掌握内容同上

回顾HashMap需要掌握什么

package se3.review;

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

/**需要掌握内容：
 * 1. 每个集合对象的创建（new）
 * 2. 向集合中添加元素
 * 3. 从集合中取出元素
 * 4. 遍历集合
 */
public class HashMapTest {
    public static void main(String[] args) {
        //创建集合
        Map<Integer,String> map = new HashMap<>();
        //添加元素
        map.put(1,"张三");
        map.put(9,"李三");
        map.put(10,"王五");
        map.put(2,"赵六");
        map.put(2,"阿波");//key可以重复，value会覆盖
        //获取元素个数
        System.out.println(map.size());//4
        //取key是2的元素
        System.out.println(map.get(2));//阿波
        //遍历Map集合很重要，几种方式都要会
        //第一种方式:先获取所有的key，遍历key的时候，通过key获取value
        Set<Integer> keys = map.keySet();
        for (Integer key : keys){
            System.out.println(key + "=" + map.get(key));
        }
        /**
         * 1=张三
         * 2=阿波
         * 9=李三
         * 10=王五
         */
        System.out.println("##################################");
        //第二种方式：将Map集合转换成Set集合，Set集合中每一个元素是Node
        //这个Node节点中有key和value
        Set<Map.Entry<Integer,String>> nodes = map.entrySet();
        for (Map.Entry<Integer,String> node : nodes){
            System.out.println(node.getKey() + "=" + node.getValue());
        }/**
         * 1=张三
         * 2=阿波
         * 9=李三
         * 10=王五
         */
    }
}

回顾Properties需要掌握什么

package se3.review;

import java.util.Properties;
/**需要掌握内容：
 * 1. 每个集合对象的创建（new）
 * 2. 向集合中添加元素
 * 3. 从集合中取出元素
 */
public class PropertiesTest {
    public static void main(String[] args) {
        //创建对象
        Properties pro = new Properties();
        //存
        pro.setProperty("username","张三");
        pro.setProperty("password","123");
        //取
        String username = pro.getProperty("username");
        String password = pro.getProperty("password");
        System.out.println(username);//张三
        System.out.println(password);//123
    }
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。