集合代码练习

continueLR

于 2021-08-21 13:46:30 发布

阅读量247

点赞数 2

文章标签： java scala python

本文链接：https://blog.csdn.net/continueLR/article/details/119838686

版权

List集合代码：ArrayList与LinkedList

package com.java.jiheWork;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
/*
    1.1、每个集合对象的创建（new）
	1.2、向集合中添加元素
	1.3、从集合中取出某个元素
	1.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);
        System.out.println(list.get(2));
        System.out.println("-------------------------------");
        // 遍历（下标方式）
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("-------------------------------");
        // 遍历（迭代器方式，这个是通用的，所有Collection都能用）
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
        System.out.println("-------------------------------");

        // while循环修改为for循环
        /*for(Iterator<String> it2 = list.iterator(); it2.hasNext(); ){
            System.out.println("====>" + it2.next());
        }*/

        // 遍历（foreach方式）
        for (String s : list) {
            System.out.println(s);
        }
        System.out.println("-------------------------------");
        LinkedList<Student> students = new LinkedList<Student>();
        Student S1 = new Student(111,"张三");
        Student S2 = new Student(122,"李四");
        Student S3 = new Student(123,"王五");
        students.add(S1);
        students.add(S2);
        students.add(S3);
        Iterator<Student> it2 = students.iterator();
        while (it2.hasNext()){
            System.out.println(it2.next());
        }
        System.out.println("-------------------------------");
        for (Student ST:students) {
            System.out.println(ST);
        }
    }
}

测试结果

总结：ArrayList集合的底层是数组，可以通过下标直接查找数据，方便查找与修改。但是在增删元素时需要移动其他元素，效率较低。

LinkedList集合底层是链表，增删时不需要移动元素，方便增删。但是每次查找都要把前面的数据都过一遍，不方便查找。

HashSet 代码

package com.bjpowernode.javase.review;

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

/*
    1.1、每个集合对象的创建（new）
	1.2、向集合中添加元素
	1.3、从集合中取出某个元素
	1.4、遍历集合
	1.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.add("abc");
        System.out.println(set.size());//3
        //这里我们发现set的元素个数只有3个，因为重复的元素无法添加到set集合当中
        System.out.println("------------------------");
        //遍历方法不能使用普通for循环，因为set集合没有下标
        //遍历方法1：迭代器方式
        Iterator<String> it = set.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        System.out.println("------------------------");
        //遍历方法2：foreach方式
        for (String s:set) {
            System.out.println(s);
        }
        System.out.println("------------------------");
        //创建Student类集合对象
        HashSet<Student> st = new HashSet<>();
        //创建Student对象，其中s3与s1重复
        Student s1 = new Student(111,"张三");
        Student s2 = new Student(222,"李四");
        Student s3 = new Student(111,"张三");
        st.add(s1);
        st.add(s2);
        st.add(s3);
        Iterator<Student> Stu = st.iterator();
        while (Stu.hasNext()){
            System.out.println(Stu.next());
        }
        System.out.println("------------------------");
            for (Student stu:st) {
                System.out.println(stu);
            }
        }
    }


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 "Student{" +
                "no=" + no +
                ", name='" + 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);
    }
}

HashSet集合的特点：底层是一个哈希表，无序不可重复。重复元素无法加入到集合中。

TreeSet代码

package com.bjpowernode.javase.review;

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

/*
    1.1、每个集合对象的创建（new）
	1.2、向集合中添加元素
	1.3、从集合中取出某个元素
	1.4、遍历集合
	1.5、测试TreeSet集合中的元素是可排序的。
	1.6、测试TreeSet集合中存储的类型是自定义的。
	1.7、测试实现Comparable接口的方式
	1.8、测试实现Comparator接口的方式（最好测试以下匿名内部类的方式）
 */
public class TreeSetTest {
    public static void main(String[] args) {
        // 集合的创建（可以测试以下TreeSet集合中存储String、Integer的。这些类都是SUN写好的。）
        //TreeSet<Integer> ts = new TreeSet<>();

        // 编写比较器可以改变规则。
        TreeSet<Integer> ts = new TreeSet<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1; // 自动拆箱
            }
        });

        // 添加元素
        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()) {
            Integer i = it.next();
            System.out.println(i);
        }

        // 遍历（foreach）
        for(Integer x : ts){
            System.out.println(x);
        }

        // 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(300));
        atree.add(new A(400));
        atree.add(new A(1000));

        // 遍历
        for(A a : atree){
            System.out.println(a);
        }

        //TreeSet<B> btree = new TreeSet<>(new BComparator());
        // 匿名内部类方式。
        TreeSet<B> btree = new TreeSet<>(new Comparator<B>() {
            @Override
            public int compare(B o1, B o2) {
                return o1.i - o2.i;
            }
        });

        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.println(b);
        }
    }
}

// 第一种方式：实现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;
        return o.i - this.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;
    }
}

HashMap代码

package com.bjpowernode.javase.review;

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

/*
    1.1、每个集合对象的创建（new）
	1.2、向集合中添加元素
	1.3、从集合中取出某个元素
	1.4、遍历集合
 */
public class HashMapTest {
    public static void main(String[] args) {
        // 创建Map集合
        Map<Integer, String> map = new HashMap<>();
        // 添加元素
        map.put(1, "zhangsan");
        map.put(9, "lisi");
        map.put(10, "wangwu");
        map.put(2, "king");
        map.put(2, "simth"); // key重复value会覆盖。
        // 获取元素个数
        System.out.println(map.size());
        // 取key是2的元素
        System.out.println(map.get(2)); // smith
        // 遍历Map集合很重要，几种方式都要会。
        // 第一种方式：先获取所有的key，遍历key的时候，通过key获取value
        Set<Integer> keys = map.keySet();
        for(Integer key : keys){
            System.out.println(key + "=" + map.get(key));
        }

        // 第二种方式：是将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());
        }
    }
}

Properties代码

package com.bjpowernode.javase.review;

import java.util.Properties;

public class PropertiesTest {
    public static void main(String[] args) {
        // 创建对象
        Properties pro = new Properties();
        // 存
        pro.setProperty("username", "test");
        pro.setProperty("password", "test123");
        // 取
        String username = pro.getProperty("username");
        String password = pro.getProperty("password");
        System.out.println(username);
        System.out.println(password);

    }
}

集合继承结构图