JAVA part 11 集合类

JAVA part 11 集合类

集合类

为什么出现集合类?
为了方便对多个对象进行操作,我们就必须把这多个对象进行存储,而想要存储多个对象,就不能是基本的变量了,应该是一个容器类型的变量。
数组StringBuilder就是一个容器类的变量,但它的结果是一个字符串,不一定满足我们的需求,所以我们只能选择数组了,而数组的长度固定,不能适应变化的需求,在这种情况下,JAVA就提供了集合类。由此可见集合类的长度是可变的。

集合的特点:
长度可变

集合的作用:
用于存储和取出数据

集合类体系结构图:
集合类体系结构图

Collection

Collection是单列集合的顶层接口
Collection表示一组对象,这些对象也称为collection
一些collection允许有重复的元素,而另一些则不允许
一些collection是有序的,而另一些是无序的
JDK不提供此接口的任何直接实现:它提供更具体的子接口(Set、List)实现

创建Collection集合的对象,采用的是多态的方式,使用激光的是具体的ArrayList类,因为这个类是最常用的集合类

Collection:
< E >:是一种特殊的数据类型,泛型。
使用的方法是在出现E的地方用引用数据类型替换即可
举例:Collection< String >,Collection< Student >

package Day_11;

import java.util.ArrayList;
import java.util.Collection;

public class test1 {
    public static void main(String[] args) {
        //创建Collection集合对象
        Collection<String> c = new ArrayList<String>();//多态的方式

        //boolean add(E e):添加元素
        c.add ("hello");
        c.add("world");
        c.add("java");

        //输出集合对象
        System.out.println(c);//输出[hello, world, java]
        //输出了集合中的元素按照直接订格式拼接的内容,说明ArrayList重写toString()方法
    }
}

Collection集合的成员方法

成员方法:
boolean add(E e):添加元素
boolean remove(Object o):移除集合元素
void clear():清空集合元素
boolean contains(Object o):判断集合中是否存在指定元素
boolean isEmpty():判断集合是否为空
int size():集合的长度,即集合中元素的个数

add:

package Day_11;

import java.util.ArrayList;
import java.util.Collection;

public class test2 {
    public static void main(String[] args) {
        //创建Collection集合对象
        Collection<String> c = new ArrayList<String>();//多态的方式

        //boolean add(E e):添加元素
        c.add ("hello");
        c.add("world");
        c.add("java");

        //输出集合对象
        System.out.println(c);

    }
}

remove:

package Day_11;

import java.util.ArrayList;
import java.util.Collection;

public class test2 {
    public static void main(String[] args) {
        //创建Collection集合对象
        Collection<String> c = new ArrayList<String>();//多态的方式
        
        c.add ("hello");
        c.add("world");
        c.add("java");

        //boolean remove(Object o):移除集合中的元素
        System.out.println("remove:"+c.remove("world"));//true
        System.out.println("remove:"+ c.remove("haha"));//false

        //输出集合对象
        System.out.println(c);
    }
}

clear:

package Day_11;

import java.util.ArrayList;
import java.util.Collection;

public class test2 {
    public static void main(String[] args) {
        //创建Collection集合对象
        Collection<String> c = new ArrayList<String>();//多态的方式

        c.add ("hello");
        c.add("world");
        c.add("java");

        //void clear():清空集合元素
        c.clear();//输出 []

        //输出集合对象
        System.out.println(c);
    }
}

contains:

package Day_11;

import java.util.ArrayList;
import java.util.Collection;

public class test2 {
    public static void main(String[] args) {
        //创建Collection集合对象
        Collection<String> c = new ArrayList<String>();//多态的方式

        c.add ("hello");
        c.add("world");
        c.add("java");
        
		//boolean contains(Object o):判断集合中是否存在指定元素
		System.out.println("contains:"+c.contains("world"));//true
        System.out.println("contains:"+c.contains("haha"));//false

        //输出集合对象
        System.out.println(c);
    }
}

isEmpty:

package Day_11;

import java.util.ArrayList;
import java.util.Collection;

public class test2 {
    public static void main(String[] args) {
        //创建Collection集合对象
        Collection<String> c = new ArrayList<String>();//多态的方式

        c.add ("hello");
        c.add("world");
        c.add("java");

        //boolean isEmpty():判断集合是否为空
        System.out.println("size:"+c.size());//空集合返回true,非空返回false

        //输出集合对象
        System.out.println(c);
    }
}

size:

package Day_11;

import java.util.ArrayList;
import java.util.Collection;

public class test2 {
    public static void main(String[] args) {
        //创建Collection集合对象
        Collection<String> c = new ArrayList<String>();//多态的方式

        c.add ("hello");
        c.add("world");
        c.add("java");

        //int size():集合的长度,即集合中元素的个数
        System.out.println("size:"+c.size());//输出size:3

        //输出集合对象
        System.out.println(c);
    }
}

Collection集合的遍历

通过使用Iterator iterator()来进行遍历
Iterator iterator():返回在此collection的元素上进行迭代的迭代器。通过集合对象调用iterator()方法得到迭代器对象

Iterator:
E next():返回迭代的下一个元素。
boolean hasNext():如果仍有元素可以迭代,返回true

package Day_11;

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

public class test3 {
    public static void main(String[] args) {

        Collection<String> c = new ArrayList<String>();/

        c.add ("hello");
        c.add("world");
        c.add("java");

        //Iterator<E> iterator()
        Iterator<String> it = c.iterator();

        //boolean hasNext()
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
    }
}

迭代器的内存图:
迭代器的内存图

集合的使用步骤:
集合的使用步骤

List集合

LIst:有序的collection(也成为序列)
此接口的有哦那个胡可以对列表中的每个元素的插入位置进行精确地控制。
用户可以根据元素的整数索引(在列表中的位置)访问元素,并搜索列表中的元素。
与set不同,列表通常允许重复的元素。

List集合的特点:
1.有序(存储和取出元素的顺序一致)
2.存储的元素可以重复

package Day_11;

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

public class test4 {
    public static void main(String[] args) {

        //创建集合对象
        List<String> list = new ArrayList<String>();

        //存储元素
        list.add("hello");
        list.add("world");
        list.add("java");
        list.add("world");

        //遍历集合
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
    }
}

List集合特有集合方法

void add(int index, E element):在指定位置添加元素
E remove(int index):删除指定位置的元素
E get(int index):获取指定位置的元素
E set(int index, E element):修改指定位置的元素

add:

package Day_11;

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

public class test5 {
    public static void main(String[] args) {

        //创建集合对象
        List<String> list = new ArrayList<String>();

        //使用继承Collection的添加功能
        list.add("hello");
        list.add("world");
        list.add("java");

        //void add(int index, E element):在指定位置添加元素
        list.add(1, "javaEE");
        //list.add(11, "javaSE");//IndexOutOfBoundsException

        //输出集合对象
        System.out.println(list);//[hello, javaEE, world, java]
    }
}

remove:

package Day_11;

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

public class test5 {
    public static void main(String[] args) {

        //创建集合对象
        List<String> list = new ArrayList<String>();

        //使用继承Collection的添加功能
        list.add("hello");
        list.add("world");
        list.add("java");

        //E remove(int index):删除指定位置的元素
        System.out.println("remove:"+list.remove(1));//[hello, java]
        //System.out.println("remove:"+list.remove(11));//IndexOutOfBoundsException

        //输出集合对象
        System.out.println(list);
    }
}

get:

package Day_11;

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

public class test5 {
    public static void main(String[] args) {

        //创建集合对象
        List<String> list = new ArrayList<String>();

        //使用继承Collection的添加功能
        list.add("hello");
        list.add("world");
        list.add("java");

        //E get(int index):获取指定位置的元素
        System.out.println("get:"+list.get(1));//get:world
        //System.out.println("get:"+list.get(11));//IndexOutOfBoundsException

        //输出集合对象
        System.out.println(list);
    }
}

set:

package Day_11;

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

public class test5 {
    public static void main(String[] args) {

        //创建集合对象
        List<String> list = new ArrayList<String>();

        //使用继承Collection的添加功能
        list.add("hello");
        list.add("world");
        list.add("java");

        //E set(int index, E element):修改指定位置的元素
        System.out.println("set:"+list.set(1, "javaEE"));//set:world

        //输出集合对象
        System.out.println(list);//[hello, javaEE, java]
    }
}i

List 普通for循环遍历

1.E get(int index):获取指位置的元素
2.int size():集合的长度,也就是集合中元素的个数

package Day_11;

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

public class test6 {
    public static void main(String[] args) {

        //创建集合对象
        List<String> list = new ArrayList<String>();

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

        //int size():集合的长度,也就是集合中元素的个数
        for(int x=0; x<list.size(); x++){
            String s = list.get(x);
            System.out.println(s);
        }
    }
}

List集合子类特点及ArrayList集合存储字符串并遍历

List:
1.ArrayList:底层数据结构是数组,查询快,增删慢
2.LinkedList:底层数据结构是链表,查询慢,增删快

ArrayList存储字符串并遍历:
1.迭代器.
2.普通for
3.增强for

package Day_11;

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

public class test8 {
    public static void main(String[] args) {

        //创建集合对象
        ArrayList<String> array = new ArrayList<String>();

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

        //迭代器
        Iterator<String> it = array.iterator();
        while(it.hasNext()){
            String s =it.next();
            System.out.println(s);
        }

        System.out.println("---------------");
        
        //普通for
        for(int x=0; x<array.size(); x++){
            String s = array.get(x);
            System.out.println(s);
        }

        System.out.println("---------------");
        
        //增强for
        for(String s : array){
            System.out.println(s);
        }
    }
}

增强for

增强for是for循环的一种

格式:

    for(元素的数据类型 变量名: 数组名或Collection集合对象名){
        变量名,这个变量名代表的是数组或者Collection集合中的元素
    }

好处:
简化了数组和Collection集合的遍历
弊端:
目标不能为null,在遍历前先对目标进行不为null的判断

代码:

package Day_11;

public class test7 {
    public static void main(String[] args) {

        //定义一个int数组
        int[] arr = {1, 2, 3, 4, 5};

        //普通for
        for(int x=0; x<arr.length; x++){
            System.out.println(arr[x]);
        }

        System.out.println("----------");

        //增强for
        for(int x : arr){
            System.out.println(x);
        }

        System.out.println("----------");

        //定义一个String数组
        String[] strArray = {"hello", "world", "java"};

        //增强for
        for(String x : strArray){
            System.out.println(x);
        }
    }
}

常见数据结构之栈和列队

栈和列队内存图

常见数据结构之数组和链表

常见数据结构之数组和链表

©️2020 CSDN 皮肤主题: 游动-白 设计师:上身试试 返回首页