【java基础，API基础三】集合、Collection常用方法、集合的遍历、增强for循环/新循环、泛型、集合与数组之间转换

居然天上楼

已于 2022-10-29 17:04:19 修改

阅读量288

点赞数

分类专栏： JAVA编程文章标签： java jvm servlet

于 2022-09-27 22:03:17 首次发布

本文链接：https://blog.csdn.net/weixin_72612071/article/details/127079616

版权

JAVA编程专栏收录该内容

32 篇文章 1 订阅

订阅专栏

点关注、不迷路

=========================================================================================以下包含代码演示========================

1. 什么是集合

- 集合和数组一样，可以保存一组数据，并且提供了操作集合元素的相关方法，使用更加方便

2. java集合框架中的相关接口

- java.util.Collection接口：是所有集合的顶级接口，封装了所有集合所共有的方法，下面有多种实现类，因此我们有更多的数据结构可以选择

- Collection接口下面有两种常见的子接口：
- java.util.List：线性表，是可以重复的集合，并且有序
- java.util.Set：不可重复集合，大部分实现类是无序的
- 集合只能存储引用类型元素

3. Collection常用方法

- add()：向集合中添加一个元素，成功添加则返回true
- size()：返回当前集合的元素个数
- isEmpty()：判断当前集合是否为空集，当且仅当size()为=时返回true
- clear()：清空集合
- contains()：判断集合是否包含给定元素
- remove()：从集合中删除给定元素，成功删除则返回true
- addAll()：将参数组定集合中的元素添加到当前集合中，添加后当前集合发生改变则返回true
- containsAll()：判断当前集合中是否包含参数集合中的所有元素
- retainAll()：取交集
- removeAll()：删交集

4. 集合的遍历

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

5. 增强for循环/新循环

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

- 语法：

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

6. 泛型

- jdk1.5时推出了一个特性：泛型
- 泛型也称为参数化类型，允许我们在使用一个类时，传入某个类型来规定其内部的属性、方法参数或返回值类型，使得我们使用的时候更加方便。
- 泛型在集合中被广泛使用，用来指定集合中元素的类型
- 若不指定泛型的具体类型，则默认为Object。
- 若指定了泛型的具体类型，在获取泛型的值时，编译器会补充强转操作。

7. 集合与数组的转换

- 集合转为数组：Collection中的方法toArray()
- 数组转为集合：Arrays类的静态方法asList()

=========================================================================================以下包含代码演示=============================

1. 什么是集合：

- 集合和数组一样，可以保存一组数据，并且提供了操作集合元素的相关方法，使用更加方便

2. java集合框架中的相关接口：

- java.util.Collection接口：是所有集合的顶级接口，封装了所有集合所共有的方法，下面有多种实现类，因此我们有更多的数据结构可以选择

- Collection接口下面有两种常见的子接口：----------------明天详细介绍
- java.util.List：线性表，是可以重复的集合，并且有序
- java.util.Set：不可重复集合，大部分实现类是无序的
- 集合只能存储引用类型元素

3. Collection常用方法：

- add()：向集合中添加一个元素，成功添加则返回true

- size()：返回当前集合的元素个数

- isEmpty()：判断当前集合是否为空集，当且仅当size()为=时返回true

- clear()：清空集合

```java
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

```java
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()：删交集

```java
package apiday03;

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

/**
* 集合间操作的演示
*/
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); //c1: [java, c++, .net]

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

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

Collection c3 = new ArrayList();
c3.add("c++");
c3.add("android");
c3.add("php");
System.out.println("c3: "+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); //c1: [c++, android]
//System.out.println("c3: "+c3); //c3: [c++, android, php]

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

4. 集合的遍历：

- Collection接口提供了统一的遍历集合的方式：迭代器模式。通过iterator()方法可以获取一个用于遍历当前集合元素的迭代器(Iterator接口)。

- java.util.Iterator接口：定义了迭代器遍历集合的相关操作，不同的集合都实现了用于遍历自身元素的迭代器实现类，但我们无需记住它们的名字，从多态的角度把它们看成Iterator即可。

- 迭代器遍历遵循的步骤为：问(hasNext())、取(next())、删(remove())，但删除并不是必要操作

```java
package apiday03;

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

/**
* 集合的遍历：迭代器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, #, tow, #, 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); //输出集合元素
}
}
```

5. 增强for循环/新循环：

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

- 语法：

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

```java
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);
}
}
}

6. 泛型：

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

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

- 泛型在集合中被广泛使用，用来指定集合中元素的类型

- 若不指定泛型的具体类型，则默认为Object。

- 若指定了泛型的具体类型，在获取泛型的值时，编译器会补充强转操作。

```java
package apiday03;

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

/**
* 泛型的演示
*/
public class GenericDemo {
public static void main(String[] args) {
Collection<Point> 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));
Iterator<Point> it = c.iterator();
while(it.hasNext()){
Point p = it.next();
System.out.println(p);
}
for(Point p : c){
System.out.println(p);
}

/*
Collection<String> c = new ArrayList<>();
c.add("one");
c.add("two");
c.add("three");
c.add("four");
c.add("five");
//c.add(123); //编译错误，参数类型违背了集合c所指定的泛型的实际类型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);
}
*/
}
}
```

7. 集合与数组的转换：

- 集合转为数组：Collection中的方法toArray()

```java
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); //[one, two, three, four, five]
//若参数数组元素个数==集合元素个数，那就正常转换
//若参数数组元素个数<集合元素个数，那就正常转换(按照集合大小给数组)
//若参数数组元素个数>集合元素个数，则正常转换，同时末尾补默认值
String[] array = c.toArray(new String[0]);
System.out.println(Arrays.toString(array));
}
}
```

- 数组转为集合：Arrays类的静态方法asList()

```java
package apiday03;

import java.util.Arrays;
import java.util.List;

/**
* 数组转换为集合:
* 数组的工具类java.util.Arrays提供了一个静态方法:asList()
* 该方法可以将一个数组转换为一个List集合
*/
public class ArrayToCollectionDemo {
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.set(2,"seven"); //将下标2的元素修改为seven
System.out.println("array: "+Arrays.toString(array));
System.out.println("list: "+list);
//添加元素/删除元素相当于要往数组中加元素/减元素
//而数组是定长的，不会自动扩容/缩容的，因此会发生不支持操作的异常
list.add("!!!!!"); //运行时发生不支持操作异常

}
}
```

居然天上楼

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
1
评论
【java基础，API基础三】集合、Collection常用方法、集合的遍历、增强for循环/新循环、泛型、集合与数组之间转换

集合、Collection常用方法、集合的遍历、增强for循环/新循环、泛型、集合与数组之间转换。集合和数组一样，可以保存一组数据，并且提供了操作集合元素的相关方法，使用更加方便- 集合和数组一样，可以保存一组数据，并且提供了操作集合元素的相关方法，使用更加方便。
复制链接

扫一扫