JavaBeans：集合、泛型

精华笔记：

什么是集合：
- 集合与数组一样，可以保存一组元素，并且提供了操作数组元素的相关方法，使用更方便
java集合框架中相关接口：
- java.util.Collection接口：是所有集合的顶级接口，封装了所有集合所共有的东西，下面有多种实现类，因此我们有更多的数据结构可以选择。
- Collection接口下面有两种常见的子接口：
  - java.util.List：线性表，是可以重复集合，并且有序
  - java.util.Set：不可重复集合，大部分实现类是无序的
- 集合只能存放引用类型元素，并且存放的是元素的引用
Collection常用方法：
- add()：向集合中添加一个元素，成功添加则返回true
- size()：返回当前集合的元素个数
- isEmpty()：判断当前集合是否为空集.当且仅当size=0时返回true.
- clear()：清空集合
- contains()：判断集合是否包含给定元素
- remove()：从集合中删除给定元素，成功删除返回true.
- addAll()：将参数给定的集合中的所有元素添加到当前集合中，添加后当前集合发生改变则返回true
- containsAll()：判断当前集合中是否包含参数集合中的所有元素
- retainAll()：取交集
- removeAll()：删交集
集合的遍历：
- Collection接口提供了统一的遍历集合的方式：迭代器模式。通过iterator()方法可以获取一个用于遍历当前集合元素的迭代器(Iterator接口)。
- java.util.Iterator接口：定义了迭代器遍历集合的相关操作。不同的集合都实现了用于遍历自身元素的迭代器实现类，我们无需记住它们的名字，从多态的角度把它们看成Iterator即可。
- 迭代器遍历遵循的步骤为：问、取、删，其中删除元素并不是必要操作
增强型for循环：
- JDK1.5时推出了一个特性：增强型for循环，也称为新循环，让我们使用相同的语法遍历集合和数组。
- 语法：
```
for(元素类型 变量名 : 集合或数组){
    循环体
}
```
泛型：
- JDK1.5时推出了一个特性：泛型
- 泛型也称为参数化类型，允许我们在使用一个类时，传入某个类型来规定其内部的属性、方法参数或返回值类型，使得我们使用的时候更加方便。
  - 泛型在集合中被广泛使用，用来指定集合中元素的类型
  - 若不指定泛型的具体类型，则默认为Object，获取泛型的值时，编译器会补充强转操作。
集合与数组的转换：
- 数组转换为List集合：----------asList()
- 集合转为数组：------------------toArray()

集合体系结构：

笔记：

什么是集合：
- 集合与数组一样，可以保存一组元素，并且提供了操作数组元素的相关方法，使用更方便
java集合框架中相关接口：
- java.util.Collection接口：是所有集合的顶级接口，封装了所有集合所共有的东西，下面有多种实现类，因此我们有更多的数据结构可以选择。
- Collection接口下面有两种常见的子接口：
  - java.util.List：线性表，是可以重复集合，并且有序
  - java.util.Set：不可重复集合，大部分实现类是无序的
- 集合只能存放引用类型元素，并且存放的是元素的引用

Collection常用方法：

add()：向集合中添加一个元素，成功添加则返回true
size()：返回当前集合的元素个数
isEmpty()：判断当前集合是否为空集.当且仅当size=0时返回true.

clear()：清空集合

package apiday03;

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

public class CollectionDemo {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add("one"); //给集合添加元素
        c.add("two");
        c.add("three");
        c.add("four");
        c.add("five");
        System.out.println(c); //Collection中重写了Object的toString()方法

        int size = c.size(); //获取集合的元素个数
        System.out.println("size:"+size); //5

        boolean isEmpty = c.isEmpty(); //判断集合是否为空集(size为0表示为空集)
        System.out.println("是否为空集:"+isEmpty); //false

        c.clear(); //清空集合
        System.out.println("集合已清空");
        System.out.println(c); //[]
        System.out.println("size:"+c.size()); //0
        System.out.println("是否为空集:"+c.isEmpty()); //true
    }
}

contains()：判断集合是否包含给定元素

remove()：从集合中删除给定元素，成功删除返回true.

package apiday03;

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

public class CollectionDemo {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add(new Point(1,2));
        c.add(new Point(3,4));
        c.add(new Point(5,6));
        c.add(new Point(7,8));
        c.add(new Point(9,0));
        c.add(new Point(1,2));
        /*
          集合重写了Object的toString()方法，格式如下:
           [元素1.toString(), 元素2.toString(), 元素3.toString(), ...]
         */
        System.out.println(c);

        Point p = new Point(1,2);
        /*
          boolean contains(Object o)
          判断当前集合是否包含给定元素，判断依据是给定元素是否与集合元素存在equals比较为true的情况
         */
        boolean contains = c.contains(p);
        System.out.println("是否包含:"+contains); //true

        /*
          boolean remove(Object o)
          从集合中删除与给定元素equals比较为true的元素，若存在重复元素则只删除一次
         */
        c.remove(p);
        System.out.println(c);
    }
}


package apiday03;
import java.util.Objects;
/**
 * 点
 */
public class Point {
    private int x;
    private int y;
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public String toString() {
        return "(" + x + "," + y + ")";
    }

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

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

    public int getX() {
        return x;
    }
    public void setX(int x) {
        this.x = x;
    }
    public int getY() {
        return y;
    }
    public void setY(int y) {
        this.y = y;
    }
}

package apiday03;
import java.util.ArrayList;
import java.util.Collection;
/**
 * 集合是存放的是元素的引用
 */
public class CollectionDemo3 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        Point p = new Point(1,2);
        c.add(p); //将p添加到集合c中
        System.out.println("p:"+p); //(1,2)
        System.out.println("c:"+c); //[(1,2)]

        p.setX(100);
        System.out.println("p:"+p); //(100,2)
        System.out.println("c:"+c); //[(100,2)]
    }
}

addAll()：将参数给定的集合中的所有元素添加到当前集合中，添加后当前集合发生改变则返回true
containsAll()：判断当前集合中是否包含参数集合中的所有元素
retainAll()：取交集

removeAll()：删交集

package apiday03;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
/**
 * 集合间操作的演示
 */
public class CollectionDemo2 {
    public static void main(String[] args) {
        Collection c1 = new ArrayList();
        c1.add("java");
        c1.add("c++");
        c1.add(".net");
        System.out.println("c1:"+c1); //[java, c++, .net]

        Collection c2 = new ArrayList();
        c2.add("android");
        c2.add("ios");
        c2.add("java");
        System.out.println("c2:"+c2); //[android, ios, java]

        /**
         * boolean addAll(Collection c)
         * 将参数给定的集合中的所有元素添加到当前集合中，添加后当前集合发生改变则返回true
         */
        c1.addAll(c2); //将c2添加到c1中
        System.out.println("c1:"+c1); //[java, c++, .net, android, ios, java]
        System.out.println("c2:"+c2); //[android, ios, java]

        Collection c3 = new ArrayList();
        c3.add("c++");
        c3.add("android");
        c3.add("php");
        System.out.println("c3:"+c3); //[c++, android, php]
        /*
          boolean containsAll(Collection c)
          判断当前集合中是否包含参数集合中的所有元素
         */
        boolean contains = c1.containsAll(c3); //判断c1中是否包含c3
        System.out.println("包含所有:"+contains);

        //取交集，c1中仅保留c1与c3的共有元素，c3不变
        //c1.retainAll(c3);
        //System.out.println("c1:"+c1); //[c++, android]
        //System.out.println("c3:"+c3); //[c++, android, php]

        //删交集，将c1中与c3的共有元素删除，c3不变
        c1.removeAll(c3);
        System.out.println("c1:"+c1); //[java, .net, ios, java]
        System.out.println("c3:"+c3); //[c++, android, php]
    }
}

集合的遍历：

Collection接口提供了统一的遍历集合的方式：迭代器模式。通过iterator()方法可以获取一个用于遍历当前集合元素的迭代器(Iterator接口)。
java.util.Iterator接口：定义了迭代器遍历集合的相关操作。不同的集合都实现了用于遍历自身元素的迭代器实现类，我们无需记住它们的名字，从多态的角度把它们看成Iterator即可。

迭代器遍历遵循的步骤为：问、取、删，其中删除元素并不是必要操作

package apiday03;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
 * 集合的遍历:
 */
public class IteratorDemo {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add("one");
        c.add("#");
        c.add("two");
        c.add("#");
        c.add("three");
        c.add("#");
        c.add("four");
        c.add("#");
        c.add("five");
        System.out.println(c); //[one, #, two, #, three, #, four, #, five]

        /*
          迭代器的常用方法:
          1)boolean hasNext()-------问
            询问集合是否还有"下一个"元素可供迭代
            注意:迭代器默认开始位置是在集合第1个元素之前
                无论调用多少次hasNext()方法，迭代器的位置都不会变
          2)Object next()-----------取
            迭代器向后移动一个位置来指向集合的下一个元素并将其获取
         */
        Iterator it = c.iterator(); //获取集合c的迭代器
        while(it.hasNext()){ //若有下一个元素
            String str = (String)it.next(); //获取下一个元素
            if("#".equals(str)){ //若str为#号
                //c.remove(str); //迭代器遍历过程中不能通过集合方法增删元素，否则会抛出异常
                it.remove(); //删除next()方法所取的元素
            }
            System.out.println(str);
        }
        System.out.println(c);

    }
}

增强型for循环：

JDK1.5时推出了一个特性：增强型for循环，也称为新循环，让我们使用相同的语法遍历集合和数组。

语法：

for(元素类型 变量名 : 集合或数组){
    循环体
}

package apiday03;

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

/**
 * 增强型for循环:新循环
 */
public class NewForDemo {
    public static void main(String[] args) {
        String[] array = {"one","two","three","four","five"};
        for(int i=0;i<array.length;i++){
            System.out.println(array[i]);
        }
        //新循环遍历数组---会被编译器改回普通的for循环
        for(String str : array){
            System.out.println(str);
        }

        Collection c = new ArrayList();
        c.add("one");
        c.add("two");
        c.add("three");
        c.add("four");
        c.add("five");
        Iterator it = c.iterator();
        while(it.hasNext()){
            String str = (String)it.next();
            System.out.println(str);
        }

        //新循环遍历集合---会被编译器改回迭代器遍历
        for(Object obj : c){
            String str = (String)obj;
            System.out.println(str);
        }
    }
}

泛型：

JDK1.5时推出了一个特性：泛型

泛型也称为参数化类型，允许我们在使用一个类时，传入某个类型来规定其内部的属性、方法参数或返回值类型，使得我们使用的时候更加方便。

泛型在集合中被广泛使用，用来指定集合中元素的类型
若不指定泛型的具体类型，则默认为Object，获取泛型的值时，编译器会补充强转操作。

package apiday03;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
 * 泛型的演示
 */
public class GenericDemo {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<>();
        c.add("one");
        c.add("two");
        c.add("three");
        c.add("four");
        c.add("five");
        //c.add(123); //编译错误，参数类型违背了集合c所指定的泛型E的实际类型String

        //迭代器所指定的泛型应当与其遍历的集合的泛型一致
        Iterator<String> it = c.iterator();
        while(it.hasNext()){
            String str = it.next(); //指定泛型后，获取元素无需再手动强转
            System.out.println(str);
        }

        for(String str : c){
            System.out.println(str);
        }
    }
}

集合与数组的转换：

数组转换为List集合：

package apiday03;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
 * 数组转换为集合:
 * 数组的工具类java.util.Arrays提供了一个静态方法:asList()
 * 该方法可以将一个数组转换为一个List集合
 */
public class ArrayToListDemo {
    public static void main(String[] args) {
        String[] array = {"one","two","three","four","five"};
        System.out.println("array:"+ Arrays.toString(array));

        //asList()方法会返回内部类ArrayList，该ArrayList内部直接引用给定数组array
        List<String> list = Arrays.asList(array);
        System.out.println("list:"+list);

        //对数组操作后，集合也会做相应的改变
        array[1] = "six";
        System.out.println("array:"+Arrays.toString(array));
        System.out.println("list:"+list);
        //对集合操作后，数组也会做相应的改变-----明天讲操作List集合

        //添加元素/删除元素相当于要往数组中加元素/减元素，
        //而数组是定长的，不会自动扩容/缩容的，因此会发生不支持操作的异常
        //list.add("!!!!!"); //运行时发生不支持操作的异常

        //如果我们需要增删元素，可另行创建一个集合同时包含list集合的元素即可
        List<String> list2 = new ArrayList<>(list); //等同于先new再addAll()
        System.out.println("list2:"+list2);
        list2.add("!!!!!");
        System.out.println("list2:"+list2);

    }
}

集合转为数组：

package apiday03;

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

/**
 * 集合转换为数组
 * Collection提供了一个方法:toArray，可以将当前集合转换为一个数组
 */
public class CollectionToArrayDemo {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<>();
        c.add("one");
        c.add("two");
        c.add("three");
        c.add("four");
        c.add("five");
        System.out.println(c);
        //若参数数组元素个数==集合元素个数，那就正常转换
        //若参数数组元素个数>集合元素个数，则正常转换，同时末尾补默认值
        //若参数数组元素个数<集合元素个数，则会按照集合大小给数组
        String[] array = c.toArray(new String[0]);
        System.out.println(Arrays.toString(array));
    }
}

posted @ 2022-09-12 19:24 Little_Monster-lhq 阅读(44) 评论(0) 编辑收藏举报

刷新页面返回顶部

little-monster-lhq

JavaBeans：集合、泛型

精华笔记：

笔记：

公告