集合框架， stack, list, set,Map,迭代器，Collection工具类笔记

最新推荐文章于 2023-07-18 14:36:17 发布

杨晓辉！

最新推荐文章于 2023-07-18 14:36:17 发布

阅读量212

点赞数 17

本文链接：https://blog.csdn.net/qq_41961660/article/details/80202121

版权

vector

vector(向量)：动态数组

为什么需要动态数组，很多时候，我们无法事先去确定数组元素的个数，如果使用了静态数组，小了不够用，大了会造成内存空间的浪费，这个时候我们就需要使用动态数组，可以按照一定的增量来增加容量。

vector的初始默认容量都是10，可以通过他的构造方法来设置容量和增量。

增量:就是在容量不够时，增加的量。

size(长度)，capacity(容量)，add(添加)，remove(int index):删除指定位置的元素。remove(Object o):删除指定元素(第一个)，trimToSize：将容量调至与数组长度相等

package 第2章_集合框架.Vector;

import java.util.Vector;

public class Test {
    public static void main(String[] args) {
        //初始容量为5，每次增量为2
        Vector<Integer> vector = new Vector<>(5,2);
        //查看Vector的容量
        System.out.println(vector.capacity());
        //查看Vector的长度
        System.out.println(vector.size());
        System.out.println("————————————");
        //存入数据
        vector.add(1);
        vector.add(2);
        vector.add(3);
        vector.add(4);
        vector.add(5);
        vector.add(6);
        vector.add(7);
        vector.add(8);
        vector.add(9);
        vector.add(10);
        vector.add(1);
        //删除数据
        vector.remove(1);//传入下标，删除指定的一个
        vector.remove(new Integer(1));//传入对象,删除指定一类数据最前面的一个
        //
        vector.trimToSize();//修整vector长度，避免空间打了浪费
        //查看Vector的容量
        System.out.println(vector.capacity());
        //查看Vector的长度
        System.out.println(vector.size());
        //删除所有
        //vector.clear();
        //通过元素寻找数组下标
        System.out.println(vector.indexOf(4));
        //通过数组下标寻找元素
        System.out.println(vector.get(3));
        //判断一个元素是否正在该数组中
        System.out.println(vector.contains(4));
        //覆盖数组中指定位置的值
        System.out.println(vector.set(3,12));
        //获取数组中的第一个元素
        System.out.println(vector.firstElement());

        System.out.println(vector.toString());
    }
}

栈(stake)

栈的特点：先进后出，后进先出。

package 第2章_集合框架.栈;

import java.util.Stack;

public class Test {
    public static void main(String[] args) {
        Stack <Integer> stack = new Stack<>();
        //栈添加的方式
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        stack.push(5);
        stack.push(6);
        stack.push(7);
        stack.push(8);
        //查看栈的最后一个元素(栈顶)
        System.out.println(stack.peek());
        //删除最后一个数(移除栈顶)
        stack.pop();
        System.out.println(stack.peek());
        //返回对象在栈中的位置，以1为基数，从下往上，从1开始
        System.out.println(stack.search(3));

//把项压入栈顶
System.out.println(stack.push(4));

}
}

List

List是一个接口，继承自collection接口，常用的实现类：ArrayList，LinkedList。

package 第2章_集合框架.List;

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

public class Test {
    public static void main(String[] args) {
        //ArrayList类实现接口List
        List <Integer> list = new ArrayList<>();

        //添加数据
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        //删除数据
        System.out.println(list.remove(4));
        System.out.println(list.remove(new Integer(3)));
        //清除数据
        //list.clear();
        // 如果列表包含指定的元素，则返回 true。
        System.out.println(list.contains(new Integer(5)));
        //返回列表中的元素数。
      System.out.println(list.size());
        //如果列表包含指定的元素，则返回 true。自动装箱
        System.out.println(list.contains(4));
        //用指定元素替换列表中指定位置的元素（可选操作）。
        System.out.println(list.set(3,12));
        //获取列表中的迭代器
        System.out.println(list.iterator());
        // 返回列表的哈希代码值。
        System.out.println(list.hashCode());
        //返回列表中首次出现指定元素的索引，或者如果列表不包含此元素，则返回 -1。
        System.out.println(list.lastIndexOf(1));
        System.out.println(list.toString());
    }
}

Set

Set也是一个接口，它表示一个无重复元素的集合，无序，唯一(它是通过判断hashCode表判断是否重复，如果得不到我们想要的结果，那就重写equals方法)。

Set的实现类：HashSet

当我们添加了重复的元素，但输出时，并没有出现重复，(set的重复的意思是a.equals(b)返回true)

package 第2章_集合框架.Set;

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

public class Test {
    public static void main(String[] args) {
        Set<Student> students = new HashSet<>();
        Student student1 = new Student("张三", Student.MALE, 18, 1140);
        Student student2 = new Student("张四", Student.MALE, 19, 1130);
        Student student3 = new Student("张五", Student.FEMALE, 28, 1110);
        Student student4 = new Student("张六", Student.MALE, 17, 1120);

        students.add(student1);
        students.add(student2);
        students.add(student3);
        students.add(student4);
        Set<Student> stu = new HashSet<>();

        System.out.println(students);
        System.out.println("-------------判断成年否---------------------------");
        findAdult(students,stu);
        System.out.println(stu);
        stu.clear();
        System.out.println("-------------判断是男是女-------------------------");
        ifFeMale(students,stu);
        System.out.println(stu);
        stu.clear();
    }

    public static void findAdult(Set<Student> students, Set<Student> set) {
        for (Student i : students) {
            if (i.getAge() >= 18) {
                set.add(i);
            }
        }
    }
    public static void ifFeMale(Set<Student> students, Set<Student> set){
        for (Student i : students) {
            if (i.getSex() == Student.FEMALE) {
                set.add(i);
            }
        }
    }
}

package 第2章_集合框架.Set;

public class Student {
    public static final byte MALE = 1;//男
    public static final byte FEMALE = 0;//女

    private String name;//姓名
    private int sex;//性别
    private int age;//年龄
    private int id;//编号

    @Override
    public boolean equals(Object obj) {
        Student student = (Student) obj;
        return student.id==this.id;
    }

    @Override
    public String toString() {
        return String.format("姓名:%s,性别:%s,年龄:%d,学号:%d\n",this.name,this.sex==0?"女":"男",this.age,this.id);
    }

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

    public int getSex() {
        return sex;
    }

    public int getAge() {
        return age;
    }
}

Map

Map是以键值对(key:value)的形式存储数据，常用有jdbc中。

Map也是无序的，且键值要求是唯一的，如果有重复的键名，以最后出现的键值为准。

package 第2章_集合框架.Map;

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

public class Test {
    public static void main(String[] args) {
        Map <String,Integer> map = new HashMap<>();
        //添加数据
        map.put("第一个数",1);
        map.put("第二个数",2);
        map.put("第三个数",3);
        map.put("第四个数",4);
        map.put("第五个数",5);
        map.put("第六个数",6);
        //查看元素个数
        System.out.println(map.size());
        //得到相对应键的值
        System.out.println(map.get("第三个数"));
        //移除相对应键的值
        map.remove("第四个数");
        System.out.println(map);
    }
}

迭代器(Iterator)

package 第2章_集合框架.迭代器;

import java.util.*;

public class Test {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("张三1");
        list.add("张三2");
        list.add("张三3");
        list.add("张三4");
        List<String> linkList = new LinkedList<String>();
        linkList.add("link1");
        linkList.add("link2");
        linkList.add("link3");
        linkList.add("link4");

        Set<String> set = new HashSet<String>();
        set.add("set1");
        set.add("set2");
        set.add("set3");
        set.add("set4");
        //使用迭代器遍历ArrayList集合
        Iterator<String> listIt = list.iterator();
        while (listIt.hasNext()) {
            System.out.println(listIt.next());
        }
        //使用迭代器遍历Set集合
        Iterator<String> setIt = set.iterator();
        while (setIt.hasNext()) {
            System.out.println(setIt.next());
        }
        //使用迭代器遍历LinkedList集合
        Iterator<String> linkIt = linkList.iterator();
        while (linkIt.hasNext()) {
            System.out.println(linkIt.next());
        }
    }
}

Collection工具类

package 第2章_集合框架.Collections工具类;

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

public class Test {
    public static void main(String[] args) {
        List<Integer>c = new ArrayList<>();
        c.add(3);
        c.add(1);
        c.add(2);
        c.add(4);
        System.out.println(c);
        //升序排序
        Collections.sort(c);
        System.out.println(c);
        //使用指定元素替换指定列表中的所有元素。
        //Collections.fill(c,new Integer(5));
        //交换集合下标的两个数
        Collections.swap(c,1,3);
        //使用默认随机源随机更改指定列表的序列。
        Collections.shuffle(c);
        // 反转指定列表中元素的顺序。
        Collections.reverse(c);
        //使用二进制搜索算法来搜索指定列表，以获得指定对象。要首先进行排序
        Collections.sort(c);
        System.out.println(Collections.binarySearch(c, 1));
        System.out.println("c"+c);
        //最大最小值
        int strMax = Collections.max(c);
       int strMin = Collections.min(c);
        System.out.println("最大值："+strMax);
        System.out.println("最小值："+strMin);
    }
}