一、集合
架构
众所周知,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 自动生成的方法存根
}
}