JavaSe基础2023年2月01日学习内容包装类和集合的使用

最新推荐文章于 2024-08-16 23:47:01 发布

森森爱学习

最新推荐文章于 2024-08-16 23:47:01 发布

阅读量92

点赞数

分类专栏： JavaSe基础文章标签：学习 java 数据结构

本文链接：https://blog.csdn.net/weixin_53214204/article/details/128851502

版权

JavaSe基础专栏收录该内容

19 篇文章 0 订阅

订阅专栏

本文介绍了Java中的包装类，如Integer，用于增强基本数据类型的功能，并在集合操作中发挥作用。接着讨论了集合的概念和重要性，包括List、ArrayList、LinkedList、Set、HashSet和TreeSet的特性及用途。还涉及了集合的遍历、元素操作以及迭代器的使用。文章最后举例展示了如何在实际编程中应用这些概念。

摘要由CSDN通过智能技术生成

JavaSe-2023-2-01 包装类和集合的使用

每日一句: 人生最重要的，不仅是努力，还有方向，压力。不是有人比你努力，而是比你牛逼几倍的人，依然比你努力。即使看不到未来，即使看不到希望，也依然相信自己错不了，依然相信，自己选的人生错不了。第二天叫醒我的不是闹钟，其实，是梦想！早安！

学习内容：包装类(Integer)、List集合、ArrayList集合、LinkedList集合、Set集合、HashSet集合、TreeSet集合

包装类
- Java语言是面向对象的编程语言，而基本数据类型声明的变量并不是对象，为其提供包装类，增强了Java面向对象的性质。
- 而且，如果只有基本数据类型，使用时是很不方便的，比如，在集合类中，无法将int 、double等类型放进去的，因为集合的容器要求元素是Object类型。此外，包装类还为基本类型添加了属性和方法，丰富了基本类型的操作。如当我们想知道int取值范围的最小值，我们需要通过运算，如下面所示，但是有了包装类，我们可以直接使用Integer.MAX_VALUE即可。
- ```
//求最大值
int max = 0;
int flag = 1;
for(int i = 0; i < 31;i++){
	max += flag;
	flag = flag << 1;
}
System.out.println(max+" " + Integer.MAX_VALUE);
```
- 八大基本类型对应着八种包装类
  - 基本类型:byte、short、int、long、float、double、boolean、char
  - 包装类:Byte、Short、Integer、Long、Float、Double、Boolean、Character
集合
- 能够方便我们对于数据的操作，存储和修改和数组不同，数组存储元素有局限性，存储类型局限，通过集合我们可以利用Java给我提供的各种API去更高效的操作数据的增删改查。
  - 集合的结构图
    -
- 数组其实就是一个集合,集合实际上就是一个容器
- 集合不能直接存储基本数据类型，也不能存储对象
- 集合也是一个对象，也有内存地址
- 在Java中每一个不同的集合，底层会对应不同的数据结构，往往不同的集合中存储元素，等于将数据放到不同的数据结构中，什么是数据结构？数据结构就是存储数据的结构，不同的数据结构存储的方式不同，所有Java集合类和集合接口都是Java.util包下
- Contains底层调用了equals方法，存放在集合中的类型，一定要重写equals方法

迭代器

要是用迭代器删除去删除，可以自动的更新迭代器，删除集合中的元素
集合状态发生改变的时候，我们要重新获取迭代器

 Iterator it = list.iterator(); //将集合转成迭代器
 while(it.hasNext()){ //判断迭代器中是否还有下一个元素
     Object o = it.next(); //获取当前元素，每一次只能调用一次
     System.out.println(o);
 }

List集合

有序、可重复、有下标

Void add(int index,Object element); //添加元素
Object get(int index); //根据下标获取元素
Int indexOf(Object o); //获取制定对象第一次出现的索引
Int lastIndexOf(Object o);//获取制定对象最后一次出现的索引
Object remove(int index);//删除元素
Object set(int index,Object element); //修改指定位置的元素

ArrayList集合

默认初始容量是10，（底层先创建一个长度为0的数组，当添加第一个元素的时候，初始化为0）
优化策略：集合扩容到原容量的1.5倍，尽量少扩容，建议使用ArralList集合的时候少扩容，预估计初始化容量
数组的缺点：随机增删元素的效率比较低，另外数组无法存储大数据量，（很难找到一块连续的内存空间）
优点：检索效率高，末尾添加元素效率不受影响

 public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add(0);
        List list = new ArrayList();
        c.add(12);
        c.add(11);
        c.add(6);
//        add(Object) 新增一个元素，存放在末尾
//        add(index,Object); 在指定位置新增元素
        c.add(1);
        System.out.println(c);
        list.add(0,2);//注意指定的位置不能超过现有元素的位置+1
        System.out.println(list);
        //2.int size();返回集中的元素个数
        System.out.println(list.size());

        //3. Object get(index); 返回指定位置的元素
        System.out.println(list.get(0));

        //4.删除 Object remove(index);
        list.remove(0);//按照下标来删除
        System.out.println(list);
        //5.boolean contain(Object); 判断集合中是否包含指定对象
//        底层使用equals方法
        List list1 = new ArrayList();
        list1.add("荔枝");
        list1.add("苹果");
        list1.add("香蕉");

        if(list1.contains("西瓜")){
            System.out.println("包含");
        }else{
            System.out.println("不包含");
        }
        list1.add(new Aoo(1,1));
        list1.add(new Aoo(1,2));
        list1.add(new Aoo(1,3));
        if(list1.add(new Aoo(1,1))){
            System.out.println("包含");
        }else{
            System.out.println("不包含");
        }
    }
}

class Aoo{
    int x;
    int y;

    public Aoo() {
    }

    public Aoo(int x, int y) {
        this.x = x;
        this.y = y;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Aoo aoo = (Aoo) o;
        return x == aoo.x && y == aoo.y;
    }

    @Override
    public int hashCode() {
        return Objects.hash(x, y);
    }
}

遍历

public static void main(String[] args) {
        List list = new ArrayList();
        list.add("荔枝");
        list.add("苹果");
        list.add("香蕉");
        list.add("李子");
        list.add("李子");
        list.add("菠萝");
        //1.使用for循环来遍历集合
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        //2.使用增强for
        for (Object o:list) {
            System.out.println(o);
        }
        //3.使用迭代器来遍历集合
        Iterator it = list.iterator(); //将集合转成迭代器
        while(it.hasNext()){ //判断迭代器中是否还有下一个元素
            Object o = it.next(); //获取当前元素，每一次只能调用一次
            System.out.println(o);
        }

//        删除李子 使用for循环的话 会造成一个问题，集合会自动补全 所以我们要从后面往前面删除
        for (int i = list.size()-1; i >= 0; i--) {
            String str = (String) list.get(i);
            if("李子".equals(str)){
                list.remove(str);
            }
        }
        System.out.println(list);
        //使用迭代器删除
        it = list.iterator();
        while(it.hasNext()){
            String str = (String) it.next();
            if("李子".equals(str)){
                it.remove();
            }
        }
        System.out.println(list);
    }

LinkedList集合

缺点：不能通过数学表达式计算查找的内存地址，每一次都是从头结点开始遍历，直到找到为止，所以LinkedList集合检索/查找的效率较低
优点：由于链表上的元素的空间存储上内存地址不连续，所以增删元素的时候不会大量元素位移，因此随机增删效率效率较高，在以后的开发中针对需要增删集合的业务上
运用

public static void main(String[] args) {
        LinkedList link = new LinkedList();
        link.add(100);
        link.add(1000);
        link.add(20);
        link.add(2,500);
        System.out.println(link);
        System.out.println(link.size());

        //在首尾添加元素
        link.addFirst(8);
        link.addLast(88);
        System.out.println(link);

        //获取元素
        Object obj = link.get(3);
        System.out.println(obj);

        //peek() 取出第一个元素放回
        System.out.println(link.peek());
        System.out.println(link);
        //poll() 取出第一个元素不放回
        System.out.println(link.poll());
        System.out.println(link);

        //删除  remove() 删除第一个元素
//        remove(index) 删除下标为index的元素
//        remove(Object) 删除一个对象
//        removeFirst()  删除第一个元素
//        removeLast() 删除最后一个元素
        link.remove();
}

Set集合

无序、不可重复、没有下标

HashSet，本质是一个HashMap所有的key值

运用

public static void main(String[] args) {
        HashSet<Integer> set = new HashSet<>();
        set.add(10);
        set.add(20);
        set.add(30);
        set.add(20);
        System.out.println(set.size());//3

        //删除remove()
        set.remove(40);
        System.out.println(set);

        //增强for
        for (Integer s: set) {
            System.out.println(s);
        }

        //迭代器
        HashSet set1 = new HashSet();
        set1.add(new Coo(1,1));
        set1.add(new Coo(1,2));
        set1.add(new Coo(1,1)); //注意重写equals方法
        System.out.println(set1.size());//3
    }
}

class Coo{
    int a;
    int b;

    public Coo() {
    }

    public Coo(int a, int b) {
        this.a = a;
        this.b = b;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Coo coo = (Coo) o;
        return a == coo.a && b == coo.b;
    }

    @Override
    public int hashCode() {
        return Objects.hash(a, b);
    }
}

TreeSet，底层是二叉树，具有排序唯一的特点

运用

 public static void main(String[] args) {
        //注意 TreeSet中添加自定义对象，对象必须使用Comparable接口
//        在ComparTo方法中定义比较规则
        TreeSet<Boo> set = new TreeSet<>();
        set.add(new Boo(1,1));
        set.add(new Boo(1,2));
        set.add(new Boo(1,3));
        set.add(new Boo(2,2));
        set.add(new Boo(2,4));
        set.add(new Boo(1,2));
        System.out.println(set.size());
        System.out.println(set);
    }
}
class Boo implements Comparable<Boo>{
    int a;
    int b;

    public Boo() {
    }

    public Boo(int a, int b) {
        this.a = a;
        this.b = b;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Boo boo = (Boo) o;
        return a == boo.a && b == boo.b;
    }

    @Override
    public int hashCode() {
        return Objects.hash(a, b);
    }

    @Override
    public String toString() {
        return "Boo{" +
                "a=" + a +
                ", b=" + b +
                '}';
    }


    @Override
    public int compareTo(Boo o) {
        return (this.a+this.b)-(o.a+o.b);
    }
}

以上仅供参考,如有不对的地方，望指出！
gitee代码仓库地址:https://gitee.com/Zhengsenbing/java-se-basic