Java高级编程06（集合框架之Collection集合）

最新推荐文章于 2023-03-21 21:56:41 发布

云破丶日出

最新推荐文章于 2023-03-21 21:56:41 发布

阅读量256

点赞数 1

分类专栏： JavaSE高级篇文章标签： java 集合

本文链接：https://blog.csdn.net/sinat_38326464/article/details/120758830

版权

JavaSE高级篇专栏收录该内容

7 篇文章 0 订阅

订阅专栏

集合

什么是集合
       集合与数组一样,可以保存一组元素,并且提供了操作元素的相关方法,使用更方便.
java集合框架中相关接口
       java.util.Collection接口:
       java.util.Collection是所有集合的顶级接口.Collection下面有多种实现类,因此我们有更多的数据结构可供选择.
       Collection下面有两个常见的子接口：
            java.util.List:线性表.是可重复集合,并且有序。
            java.util.Set:不可重复的集合,大部分实现类是无序的。
       这里可重复指的是集合中的元素是否可以重复，而判定重复元素的标准是依靠元素自身equals比较的结果，为true就认为是重复元素。

package collection;
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo {
	public static void main(String[] args) {
	Collection c = new ArrayList();
	/*
	boolean add(E e)
	向当前集合中添加一个元素.当元素成功添加后返回true
	*/
	c.add("one");
	c.add("two");
	c.add("three");
	c.add("four");
	c.add("five");
	System.out.println(c);
	/*
	int size()
	返回当前集合的元素个数
	*/
	int size = c.size();
	System.out.println("size:"+size);
	/*
	boolean isEmpty()
	判断当前集合是否为空集(不含有任何元素)
	*/
	boolean isEmpty = c.isEmpty();
	System.out.println("是否为空集:"+isEmpty);
	/*
	清空集合
	*/
	c.clear();
	System.out.println(c);
	System.out.println("size:"+c.size());//0
	System.out.println("是否为空集:"+c.isEmpty());
	}
}

集合与元素equals方法相关的方法

package collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
/**
* 集合的很多操作有与元素的equals方法相关。
*/
public class CollectionDemo2 {
	public static void main(String[] args) {
	// Collection c = new ArrayList();
	Collection c = new HashSet();
	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(1,2));
	/*
	集合重写了Object的toString方法，输出的格式为:
	[元素1.toString(), 元素2.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);
	/*
	remove用来从集合中删除给定元素，删除的也是与集合中equals比较
	为true的元素。注意，对于可以存放重复元素的集合而言，只删除一次。
	*/
	c.remove(p);
	System.out.println(c);
	}
}

集合存放的是元素的引用
集合只能存放引用类型元素,并且存放的是元素的引用。

package com.scy.array;

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);
			System.out.println("p:"+p);//p:Point [x=1, y=2]
			System.out.println("c:"+c);//c:[Point [x=1, y=2]]
			
			p.setX(2);
			System.out.println("p:"+p);//p:Point [x=2, y=2]
			System.out.println("c:"+c);//c:[Point [x=2, y=2]]
	}
}

在这里插入图片描述
集合间的操作
集合提供了如取并集，删交集，判断包含子集等操作。

package com.scy.array;

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

/**
 * 集合间的操作
 * 
 * 集合提供了如取并集，删交集，判断是否包含子集等操作。
 * 
 * @author Administrator
 *
 */
public class CollectionDemo4 {

	public static void main(String[] args) {

		//Collection c1 = new ArrayList();
		Collection c1 = new HashSet();//不可重复元素
		c1.add("JAVA");
		c1.add("C++");
		c1.add("C语言");
		c1.add("Python");
		System.out.println("c1："+c1);
		
		Collection c2 = new ArrayList();
		c2.add("android");
		c2.add("ios");
		c2.add("JAVA");
		System.out.println("c2："+c2);
		
		/**
		 * 将给定集合中的元素添加到当前集合中，当前集合若发生了改变则返回trues
		 * boolean addAll(Collection c)
		 */
		boolean b1 = c1.addAll(c2);
		System.out.println(b1);
		System.out.println("c1:"+c1);
		System.out.println("c2:"+c2);
		
		Collection c3 = new ArrayList();
		c3.add("C++");
		c3.add("JAVA");
		c3.add("Python");
		System.out.println("c3:"+c3);
		
		/**
		 * 判断当前集合是否包含给定集合中的所有元素
		 * boolean containsAll(Collection c)
		 */
		boolean b2 = c1.containsAll(c3);
		System.out.println(b2);
		
		/**
		 * 删除当前集合中与给定集合中的共有元素
		 *boolean  removeAll(Collection c)
		 */
		c1.removeAll(c3);
		System.out.println("c1："+c1);
		System.out.println("c3："+c3);
	}
}

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

package com.scy.array;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
 * Collection接口没有定义单独获取某一个元素的操作，因为不通用。
 * 但是Collection提供了遍历集合元素的操作。该操作是一个通用操作，无论什么类型的
 * 集合都支持此种遍历方式:迭代器模式。
 *
 * Iterator iterator() die(二声)
 * 该方法会获取一个用于遍历当前集合元素的迭代器
 *
 * java.util.Iterator接口，是迭代器接口，规定了迭代器遍历集合的相关操作，不同的
 * 集合都提供了一个用于遍历自身元素的迭代器实现类，不过我们不需要直到它们的名字，以
 * 多态的方式当成Iterator使用即可。
 * 迭代器遍历集合遵循的步骤为:问->取->删
 * 其中删除不是必须操作。
 *
 */
public class IteratorDemo {
	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);
		//获取迭代器
		Iterator it = c.iterator();
		/*
		迭代器提供的相关方法：
		boolean hasNext()
		判断集合是否还有元素可以遍历
		E next()
		获取集合下一个元素(第一次调用时就是获取第一个元素，以此类推)
		 */
		while(it.hasNext()){
			String str = (String)it.next();
			System.out.println(str);
		}
		System.out.println(c);
	}
}

迭代器遍历过程中不得通过集合的方法增删元素

package com.scy.array;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
 * Collection接口没有定义单独获取某一个元素的操作，因为不通用。
 * 但是Collection提供了遍历集合元素的操作。该操作是一个通用操作，无论什么类型的
 * 集合都支持此种遍历方式:迭代器模式。
 *  * Iterator iterator() die(二声)
 * 该方法会获取一个用于遍历当前集合元素的迭代器
 *  * java.util.Iterator接口，是迭代器接口，规定了迭代器遍历集合的相关操作，不同的
 * 集合都提供了一个用于遍历自身元素的迭代器实现类，不过我们不需要直到它们的名字，以
 * 多态的方式当成Iterator使用即可。
 * 迭代器遍历集合遵循的步骤为:问->取->删
 * 其中删除不是必须操作。
 *  */
public class IteratorDemo2 {
	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);
		//获取迭代器
		Iterator it = c.iterator();
		//迭代器提供的相关方法：
		//boolean hasNext()
		/*判断集合是否还有元素可以遍历
		 *E next()
		 *获取集合下一个元素(第一次调用时就是获取第一个元素，以此类推)
		 */
		while(it.hasNext()){
			String str = (String)it.next();
			System.out.println(str);
			if("#".equals(str)){
				/*
				 *迭代器要求遍历的过程中不得通过集合的方法增删元素
				 *否则会抛出异常:ConcurrentModificationException
				 */
				// c.remove(str);
				/*
				 *迭代器的remove方法可以将通过next方法获取的元素从集合
				 *中删除。
				 */
				it.remove();
			}
		}
		System.out.println(c);
	}
}

增强型for循环
JDK5之后推出了一个特性:增强型for循环

也称为新循环,使得我们可以使用相同的语法遍历集合或数组
语法:

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

package com.scy.array;

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

/**
 * jdk5之后推出新的特性：增强for循环
 * 也称为新循环，使得我们可以使用相同的语法遍历集合和数组
 * 语法为：
 *  for(元素类型 变量名: 集合或数组){
 *  	循环体;
 *  } 
 *  
 *新循环是为Java编译器认可的，并非虚拟机
 *
 */
public class NewForDemo {
	public static void main(String[] args) {
		//创建字符串数组
		String[] array = {"one","two","three","four","five"};

		//传统的for循环遍历数组
		for(int i=0;i<array.length;i++) {
			String str=array[i];
			System.out.println(str);
		}
		System.out.println("=======1 end=======");
		//增强for循环遍历
		for(String str1 : array ) {
			System.out.println(str1);
		}
		System.out.println("======2end========");
		//创建集合
		Collection c = new ArrayList();
		//给集合添加元素
		c.add("one");
		c.add("two");
		c.add("three");
		c.add("four");
		c.add("five");
		//自动装箱
		//Integer i= new Integer(123);
		//c.add(123);
		//迭代器遍历集合
		Iterator it = c.iterator();
		while(it.hasNext()) {
			String str = (String)it.next();
			System.out.println(str);
		}
		System.out.println("======3 end========");
		//增强for循环遍历集合
		for(Object obj : c) {
			String str=(String)obj;
			System.out.println(obj);
		}
		System.out.println("=====4 end=========");
	}
}

泛型

JDK5之后推出的另一个特性。
泛型也称为参数化类型，允许我们在使用一个类时指定它里面属性的内容，方法参数或返回值类型。

泛型被广泛应用于集合中，用来指定集合中的元素类型。
支持泛型的类在使用时如果未指定泛型，那么默认就是Object。

	/**
		 * 泛型： JDK5之后推出的另一个特性
		 * 泛型也称为参数化类型，允许我们在使用一个类时指定它里面属性的内容
		 * 方法参数或返回值类型，使得我们使用一个类可以更灵活。
		 * 泛型被广泛应用于集合中，用来指定集合中的元素类型。
		 * 支持泛型的类在使用时如果未指定泛型，那么默认就是Object
		 * 
		 * Collection接口的定义
		 * public interface Collection<E> ... {
		 *  
		 *  Collection<E> 这里的<E>就是泛型
		 *  
		 *  Collection中add的方法定义，参数为E
		 *  
		 *   boolean add(E e);
		 *  
		 */
package com.scy.array;

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

public class NewForDemo {
	public static void main(String[] args) {
		//创建集合指定泛型为String类型
		Collection<String> coll = new ArrayList();
		//给集合添加元素
		coll.add("one");//编译器会检查add方法的实际参数是否为String类型。
		coll.add("two");
		coll.add("three");
		coll.add("four");
		coll.add("five");
		//coll.add(123);//编译不通过 类型不符
		
		//迭代器遍历
		//迭代器也支持泛型，指定的与遍历的集合指定的泛型一致即可。
		Iterator<String> iterator = coll.iterator();
		while(iterator.hasNext()) {
			//编译器在编译代码时会根据迭代器指定的泛型补充造型代码
			String str = iterator.next();//获取元素是无需在强制类型转换
			System.out.println(str);
		}
		System.out.println("=====5 end=========");
		
		//新循环的快捷键  输入 fore  alt + /  回车即可  会自动遍历最靠近当前代码的集合
		for (String string : coll) {
			System.out.println(string);
		}
	}
}

云破丶日出

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java高级编程06（集合框架之Collection集合）

集合什么是集合       集合与数组一样,可以保存一组元素,并且提供了操作元素的相关方法,使用更方便.java集合框架中相关接口       java.util.Collection接口:       java.util.Collection是所有集合的顶级接口.Collection下面有
复制链接

扫一扫