java:collection集合、Iterator迭代器、foreach 增强for、泛型

一、集合

架构
在这里插入图片描述
众所周知,Java的数组长度是固定的,但是在实际中某些情况,甲方是会变来变去的。这里引入Colleciton,集合的长度是可变的,而且类型可以是混合的。

  • public boolean add(E e): 把给定的对象添加到当前集合中 。
  • public void clear() :清空集合中所有的元素。
  • public boolean remove(E e): 把给定的对象在当前集合中删除。
  • public boolean contains(E e): 判断当前集合中是否包含给定的对象。
  • public boolean isEmpty(): 判断当前集合是否为空。
  • public int size(): 返回集合中元素的个数。
  • public Object[] toArray(): 把集合中的元素,存储到数组中。
混合类型的集合
import java.util.ArrayList;
import java.util.Collection;

public class test9 {	
		
	public static void main(String[] args)  {
		Collection coll = new ArrayList();
		coll.add("abc");
		coll.add('c');
		coll.add(5);//由于集合没有做任何限定,任何类型都可以给其中存放
		System.out.println(coll);
	}
}

输出

[abc, c, 5]

指定String类型的集合
package test;

import java.text.DateFormat;
import java.text.ParseException;
import java.util.Calendar;
import java.util.Date;
import java.util.Scanner;
import java.util.logging.SimpleFormatter;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;

public class test9 {	
		
	public static void main(String[] args)  {
		// 创建集合对象 
    	// 使用多态形式
		//Collection<E> 变量名字=new ArrayList<E>(); 
		//ArrayList 可以换其他的
		Collection<String> collection=new ArrayList<String>();
		
		// 添加使用方法
    	collection.add("哈哈");
    	collection.add("test");
    	collection.add("333");
    	System.out.println(collection);
    	//输出 [哈哈, test, 333]
    	
    	//判断其中是否存在
    	System.out.println("判断 test 是否在集合中"+collection.contains("test"));
    	//输出判断 test 是否在集合中true
    	
    	collection.remove("333");
    	System.out.println(collection);
    	//输出[哈哈, test]
    	
    	System.out.println(collection.size());  	
    	//输出2
    	
    	Object[] objects=collection.toArray();
    	for (int i = 0; i < objects.length; i++) {
			System.out.println(objects[i]);			
		}
    	//输出
    	//2
    	//哈哈
    	//test
    	
    	collection.clear();
    	System.out.println(collection);
    	//输出[]
    	System.out.println(collection.isEmpty());
    	//输出true
    	
	}

}

二、Iterator迭代器

集合是个整体,没办法像a[3]这样取值处理(目前没学到),就要用Iterator迭代器来处理

下面介绍一下迭代的概念:
  • 迭代:即Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素,如果有,就把这个元素取出来,继续在判断,如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。
Iterator迭代器常用方法
  • public E next():返回迭代的下一个元素。
  • public boolean hasNext():如果仍有元素可以迭代,则返回 true。
import java.util.ArrayList;
import java.util.Collection;

public class test9 {	
		
	public static void main(String[] args)  {
		// 创建集合对象 
    	// 使用多态形式
		//Collection<E> 变量名字=new ArrayList<E>(); 
		//ArrayList 可以换其他的
		Collection<String> collection=new ArrayList<String>();
		
		// 添加使用方法
    	collection.add("哈哈");
    	collection.add("test");
    	collection.add("333");
    	
    	Iterator<String> iterator=collection.iterator();
    	
    	while (iterator.hasNext()) {
			String string=iterator.next();
			System.out.println(string);
			
		}  	
	}
}

在这里插入图片描述

原理:

当遍历集合时,首先通过调用t集合的iterator()方法获得迭代器对象,然后使用hashNext()方法判断集合中是否存在下一个元素,如果存在,则调用next()方法将元素取出,否则说明已到达了集合末尾,停止遍历元素。

三、foreach

1)普通的foreach

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

public class test9 {	
		
	public static void main(String[] args)  {
		Collection<String> collection=new ArrayList<String>();
		collection.add("嘻嘻");
		collection.add("呵呵");
		collection.add("233");
		//foreach
		for (String str : collection) {//接收变量str 代表被遍历到的集合元素
			System.out.println(str);
		}
    	
	}
}

在这里插入图片描述
2)不同类型的集合的foreach

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

public class test9 {	
		
	public static void main(String[] args)  {
		Collection collection=new ArrayList();
		collection.add("嘻嘻");
		collection.add('c');
		collection.add(233);
		
		for (Object Object : collection) {
			System.out.println("类型:"+Object.getClass().getName()+"  值:"+Object);
		}
	}
}

在这里插入图片描述

四、泛型

1、简单例子

在这里插入图片描述
集合虽然可以存放任意对象,只要把对象存储集合后,那么他们都会被提升为object类型,当我们在取出每一个对象,并且进行相应的操作,这时必须采用类型转换。但是看下面这个例子(与Iterator接口的对比)

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

public class test9 {	
		
	public static void main(String[] args)  {
		Collection coll = new ArrayList();
		coll.add("abc");
		coll.add("itcast");
		coll.add(5);//由于集合没有做任何限定,任何类型都可以给其中存放
		Iterator it = coll.iterator();
		while(it.hasNext()){
			//需要打印每个字符串的长度,就要把迭代出来的对象转成String类型
			String str = (String) it.next();
			System.out.println(str.length());
		}
	}
}

输出

3
6
Exception in thread “main” java.lang.ClassCastException: class java.lang.Integer cannot be cast to class java.lang.String (java.lang.Integer and java.lang.String are in module java.base of loader ‘bootstrap’)
at test/test.test9.main(test9.java:24)

可以看到,虽然我们是用了强制转换,但是Collection虽然可以存储各种对象,但实际上通常Collection只存储同一类型对象。就有会这种迷之BUG产生,那么就催生了泛型的产生
所以,最标准就是泛型里面 < E > 里面写的什么,迭代器取出来的就是什么类型
其实再上面的迭代器的例子,就已经使用了泛型

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

public class test9 {	
		
	public static void main(String[] args)  {
		// 创建集合对象 
    	// 使用多态形式
		//Collection<E> 变量名字=new ArrayList<E>(); 
		//ArrayList 可以换其他的
		Collection<String> collection=new ArrayList<String>();
		
		// 添加使用方法
    	collection.add("哈哈");
    	collection.add("test");
    	collection.add("333");
    	
    	Iterator<String> iterator=collection.iterator();
    	
    	while (iterator.hasNext()) {
			String string=iterator.next();
			System.out.println(string);
			
		}  	
	}
}

这玩意就已经是泛型了,这是一个普通的基础的泛型

2、自定义泛型

当某个傻逼甲方突然要改一个对象的属性时,我们要重写很多代码,要改类型,然后函数也要改类型,但是用了自定义泛型后,可以避免这些麻烦

public class Generic<E> {
	E name;

	// 构造方法
	public Generic(E name) {
		this.name = name;
	}

	// 设置属性变量
	public void setName(E name) {
		this.name = name;
	}

	// 获得属性变量
	public E getName() {
		return name;
	}
}


public class demo1 {

	public static void main(String[] args) {
		// 创建Generic对象,泛型使用Integer类型
		Generic<Integer> gc1 = new Generic<Integer>(123);
		System.out.println(gc1.getName());

		// 创建Generic对象,泛型使用String类型
		Generic<String> gc2 = new Generic<String>("小明");
		System.out.println(gc2.getName());

	}

}

123
小明

可以看出,Generic类定义了泛型,我们可以用string或者integer类型来构造属性,用来给不确定的类使用

3、泛型方法
public class demo1 {

	public static void main(String[] args) {
		test("String");
		test(123);
		test(true);
	}

	private static <E> void test(E e) {
		// TODO 自动生成的方法存根
		System.out.println(e.getClass().getName());//输出类型
	}

}

java.lang.String
java.lang.Integer
java.lang.Boolean

4、泛型接口

定义格式
修饰符 interface接口名<代表泛型的变量> { }

1)接口用泛型,定义类时已经确定泛型类型
//泛型接口
public interface GenericInterface<E>{
	public abstract void getType(E e);
}

//Generic类已经确定要用String类型了
public class Generic implements GenericInterface<String>{

	@Override
	public void getType(String e) {
		// TODO 自动生成的方法存根
		System.out.println(e+" "+e.getClass().getName());
	}
	
}
public class demo1 {

	public static void main(String[] args) {
		Generic generic=new Generic();
		generic.getType("小明");
	}

}

小明 java.lang.String

2)接口用泛型,定义类时还不确定用什么类型,创建对象的时候才决定泛型类型
public interface GenericInterface<E>{
	public abstract void getType(E e);
}

public class Generic<E> implements GenericInterface<E> {

	@Override
	public void getType(E e) {
		// TODO 自动生成的方法存根
		System.out.println(e + " " + e.getClass().getName());
	}

}
public class demo1 {

	public static void main(String[] args) {
		Generic<Integer> generic=new Generic<Integer>();
		generic.getType(123);
	}

}

123 java.lang.Integer

5、泛型通配符

当使用泛型类或者接口传递数据(函数传递数据)的时候,泛型不确定,可以用通配符<?>表示。但是一旦使用泛型的通配符后,只能使用Object类中的共性方法,集合中元素自身方法无法使用。
泛型的通配符:不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符。

package restudy;

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

public class demo1 {

	public static void main(String[] args) {
		Collection<Integer> list1 = new ArrayList<Integer>();
		list1.add(1);
		list1.add(2);
		printArr(list1);
		
		Collection<String> list2 = new ArrayList<String>();
		list2.add("小明");
		list2.add("小兰");
		printArr(list2);

	}

	//该函数要接受任意类型的泛型
	private static void printArr(Collection<?> collection) {
		//Iterator要接受的是什么类型也不知道,也可以用?通配符
		Iterator<?> iterator = collection.iterator();
		while (iterator.hasNext()) {
			Object o = iterator.next();//得到的都是object类型
			System.out.println(o + "  " + o.getClass().getName());

		}
	}

}

1 java.lang.Integer
2 java.lang.Integer
小明 java.lang.String
小兰 java.lang.String

6、受限泛型

之前设置泛型的时候,实际上是可以任意设置的,只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限下限

泛型的上限

  • 格式类型名称 <? extends 类 > 对象名称
  • 意义只能接收该类型及其子类

泛型的下限

  • 格式类型名称 <? super 类 > 对象名称
  • 意义只能接收该类型及其父类型

已经知道继承关系:
Integer extends Number extends Object
String extends Object

package restudy;

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

public class demo1 {

	public static void main(String[] args) {
		Collection<Integer> list1 = new ArrayList<Integer>();
		Collection<String> list2 = new ArrayList<String>();
		Collection<Number> list3 = new ArrayList<Number>();
		Collection<Object> list4 = new ArrayList<Object>();

		getElement(list1);
		// getElement(list2);// 报错,因为String不是number子类
		getElement(list3);
		// getElement(list4);// 报错,因为Object是Number父类而不是子类

		// getElement2(list1);// 报错,因为Integer是Number子类不是其父类
		// getElement2(list2);// 报错,,因为String不是number父类
		getElement2(list3);
		getElement2(list4);

	}

	// 这个方法的参数必须是Number类型或者其 子 类才能使用
	private static void getElement(Collection<? extends Number> collection) {
		// TODO 自动生成的方法存根

	}

	// 这个方法的参数必须是Number类型或者其 父 类才能使用
	private static void getElement2(Collection<? super Number> collection) {
		// TODO 自动生成的方法存根

	}

}

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值