【java基础】09-集合01

最新推荐文章于 2024-11-15 18:38:47 发布

Nusret

最新推荐文章于 2024-11-15 18:38:47 发布

阅读量690

点赞数

分类专栏： Java基础文章标签： java 开发语言

本文链接：https://blog.csdn.net/Nusret/article/details/123611262

版权

Java基础专栏收录该内容

16 篇文章 1 订阅

订阅专栏

1.集合概述-集合与数组的对比

集合是java中,提供的一种容器,可以保存多个数据.

集合与数组的区别:

2.集合概述-集合体系结构

集合体系结构
简化体系:
简化集合体系
扩展:

\1. 集合体系的由来:子类共性抽取,提炼成父类/接口

\2. 集合的学习目标: crud(增删改查) + 遍历 +  每种集合各自特点
\3. 集合的学习方式
	先学哪个?
			先学顶层(从上到下):共性方法
			共性学一遍,其他底层实现类都学了一遍
	使用哪个?
			使用底层实现类(方法更多) 
                
问题:集合类为什么有这么多?
	为了满足不同的需求,元素重复,不重复的,有序,无序,排序

3.Collection-常见成员方法

Collection集合常用方法1
Collection集合常用方法2
Collection集合常用方法3

4.Collection-迭代器基本使用

迭代器介绍
1. 迭代器,集合的专用遍历方式
2. Iterator iterator():返回此集合中元素的迭代器,通过集合对象的iterator()方法得到
Iterator中的常用方法
boolean hasNext():判断当前位置是否有元素可以被取出
E next():获取当前位置的元素,将迭代器对象移向下一个索引位置
Collection集合的遍历

  public class IteratorDemo1 {
    public static void main(String[] args) {
        //创建集合对象
        Collection<String> c = new ArrayList<>();

        //添加元素
        c.add("hello");
        c.add("world");
        c.add("java");
        c.add("javaee");

        //Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到
        Iterator<String> it = c.iterator();

        //用while循环改进元素的判断和获取
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }
    }
}

要点:

遍历: 将集合中的元素挨个取出,进行处理(最常见的处理是打印)

迭代器遍历: 所有 Collection 集合都可以使用

使用步骤

1.创建集合
2.添加元素
3.通过集合获取迭代器(集合.iterator())
4.使用迭代器(hasNext(),next())

5.Collection-迭代器原理分析

迭代器原理
迭代器成员方法
要点

理解下,迭代器中有一个指针,默认指向集合第一个元素
hasNext(),只判断,不移动指针
next(),返回当前元素,并移动指针到下一个位置

6.Collection-迭代器删除方法

Collection删除-迭代器删除1
Collection删除-迭代器删除2
要点

1.理解ArrayList的特有方法删除重复元素, get(index),size()

2.遍历时, 可以通过Iterator迭代器删除元素 (remove():删除从迭代器返回的最后一个元素)

注意:通过迭代器遍历时, 不能直接通过集合本身修改集合!! (添加或删除元素)

interface Iterator
iterator成员方法
扩展: 通过迭代器遍历时,不能直接通过集合本身修改集合!!(添加或删除元素)
迭代器调用删除方法时出现异常

ConcurrentModificationException 是什么异常?
	并发修改异常
原因:
	当对象不允许并发修改时,抛出此异常
    通俗说,将集合交给迭代器遍历,在迭代器遍历过程中,不通过迭代器,直接通过集合修改(添加/删除),就会抛出此异常
解决:
    1.迭代器遍历时,使用迭代器进行修改
    2.使用其他遍历方式,例如:get(index),size()

7.增强for-基本格式

增强for基本格式1

Collection<String> list =  new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("f");

        //1,数据类型一定是集合或者数组中元素的类型
        //2,str仅仅是一个变量名而已,在循环的过程中,依次表示集合或者数组中的每一个元素
        //3,list就是要遍历的集合或者数组.
        for(String str : list){
            System.out.println(str);
        }

要点

格式:
    for (元素类型 变量名 : 数组/Collection集合) {
            使用 变量名
    }
   例如:
	   for (String s : list){
            System.out.println(s);
        }

作用:简化 Collection 集合和 数组 的遍历
    
底层: 
	底层也是迭代器(不要一边遍历,一边通过集合修改元素)        

遍历首选
别名: 增强for(超级for,forEach) 
	

快捷键：
    集合/数组对象.for 
    集合/数组名.iter
    iter + 回车

8.增强for-注意点

增强for注意点

 ArrayList<String> list =  new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
//
//        for(String str : list){
//            str = "q";
//            System.out.println(str);
//        }
        for (String s : list) {
            System.out.println(s);
        }

9.Collection转数组

 Object[] objects = list.toArray();
        Student[] stuArray = new Student[list.size()];
        list.toArray(stuArray);
        for (Student stu : stuArray) {
            System.out.println(stu);
        }

10.List-概述和基本使用

List示例代码

List<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
	
		//List 就当Collection一样遍历
        Iterator<String> it = list.iterator();

        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("---------------------");
        for (String s : list) {
            System.out.println(s);
        }

要点

Collection体系
    	Collection(接口)
    	List(子接口):     特点,有序,可重复,有索引    			
    			ArrayList<>
List特点
	List 就当 Collection 用 (创建集合,添加元素,迭代器,增强for遍历)
验证有序,可重复

List的特点

有序 (存储和取出的顺序一致)
可重复
有索引(有针对索引操作的方法)

11.List-特有方法

List集合特有方法

public class MyListDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        //method1(list);
        //method2(list);
        //method3(list);
        //method4(list);
    }

    private static void method4(List<String> list) {
        //        E get(int index)		返回指定索引处的元素
        String s = list.get(0);
        System.out.println(s);
    }

    private static void method3(List<String> list) {
        //        E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
        //被替换的那个元素,在集合中就不存在了.
        String result = list.set(0, "qqq");
        System.out.println(result);
        System.out.println(list);
    }

    private static void method2(List<String> list) {
        //        E remove(int index)		删除指定索引处的元素，返回被删除的元素
        //在List集合中有两个删除的方法
        //第一个 删除指定的元素,返回值表示当前元素是否删除成功
        //第二个 删除指定索引的元素,返回值表示实际删除的元素
        String s = list.remove(0);
        System.out.println(s);
        System.out.println(list);
    }

    private static void method1(List<String> list) {
        //        void add(int index,E element)	在此集合中的指定位置插入指定的元素
        //原来位置上的元素往后挪一个索引.
        list.add(0,"qqq");
        System.out.println(list);
    }
}

要点

List的特点
	1.有序 2. 可重复, 3 . 有索引 (可根据索引CRUD(增删改查))
特有功能
	根据索引curd, 遍历(迭代器, 增强for, 普通for(List特有))

12.数据结构-栈和队列

数据结构概念
栈:

进栈, 也叫压栈

出栈, 也叫弹栈

特点:

先进后出.
数据结构之栈
队列:

入队

出队

特点:

先进先出
数据结构之队列

13.数据结构-数组和链表

数据结构-数组
数据结构-链表
单向链表-双向链表
要点

数组结构的特点:

		查询?,增删??

为什么?

   查询快? 数组是一片连续的内存空间,而且有编号(索引)

   增删慢? 数组添加元素或删除元素有可能移动元素

链表:

		由一个个节点组成, 节点保存的是数据和下一个节点的地址

特点: 

		查询?,增删?

查询慢? 每个节点的地址不是连续的, 每次都从头或从尾查.

增删快? 因为添加元素和删除元素不影响链表的整体结构,只记录地址,不移动元素.(好像牵手和放手)

14.ArrayList-源码解析

ArrayList源码解析1
size : 当前元素个数

size : 新元素要添加的索引位置

ArrayList源码解析2
ArrayList源码解析3

15.LinkedList-基本运用

LinkedList遍历

16.LinkedList-特有功能

LinkedList-特有功能

public class MyLinkedListDemo4 {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
//        public void addFirst(E e)	在该列表开头插入指定的元素
        //method1(list);

//        public void addLast(E e)	将指定的元素追加到此列表的末尾
        //method2(list);

//        public E getFirst()		返回此列表中的第一个元素
//        public E getLast()		返回此列表中的最后一个元素
        //method3(list);

//        public E removeFirst()		从此列表中删除并返回第一个元素
//        public E removeLast()		从此列表中删除并返回最后一个元素
        //method4(list);
      
    }

    private static void method4(LinkedList<String> list) {
        String first = list.removeFirst();
        System.out.println(first);

        String last = list.removeLast();
        System.out.println(last);

        System.out.println(list);
    }

    private static void method3(LinkedList<String> list) {
        String first = list.getFirst();
        String last = list.getLast();
        System.out.println(first);
        System.out.println(last);
    }

    private static void method2(LinkedList<String> list) {
        list.addLast("www");
        System.out.println(list);
    }

    private static void method1(LinkedList<String> list) {
        list.addFirst("qqq");
        System.out.println(list);
    }
}

要点

LinkedList底层是?特点是?
		链表, 查询慢,增删快
		像一条蛇,有头尾,
特有功能
	有专门针对头和尾操作的功能
    添加到头,添加到尾
    获取头,获取尾
    删除头,删除尾

    addFirst(E);
    addLast(E);
    E removeFirst();
    E removeLast();
    E getFirst();
    E getLast();