本帖最后由 小石姐姐 于 2018-9-14 15:15 编辑
就业班JavaSE第二阶段第2天
day02【Collection、泛型】
- Collection集合
集合是java中提供的一种容器，可以用来存储多个数据
集合和数组的区别：
数组的长度是固定的，集合的长度是可变的
数组中存储的是同一类型的元素，可以存储基本数据类型。集合存储的都是对象。
而且对象的类型可以不一致
List接口：Vector集合、ArrayList集合、LinkedList集合
有序的集合（存储和取出元素顺序相同）
允许存储重复的元素
有索引，可以使用普通的for循环遍历
Set接口：
不允许存储重复元素
没有索引（不能使用普通for循环遍历）
常用方法；
[Java] 纯文本查看 复制代码 import java.util.ArrayList;
import java.util.Collection;
[AppleScript] 纯文本查看 复制代码 public class CollectionTest01 {
public static void main(String[] args) {
//创建集合对象
Collection<String> coll = new ArrayList<>();
System.out.println(coll);//重写了toString()方法
//public boolean add(E e)： 把给定的对象添加到当前集合中 。
boolean b = coll.add("赵丽颖");
System.out.println(b);
System.out.println(coll);
coll.add("刘亦菲");
coll.add("高圆圆");
coll.add("唐嫣");
[AppleScript] 纯文本查看 复制代码 //public boolean remove(E e): 把给定的对象在当前集合中删除。
//返回值是一个boolean值，集合中存在元素，返回true
//集合中不存在元素，删除失败，返回false
boolean b1 = coll.remove("杨幂");
System.out.println("b1:" + b1);
[Java] 纯文本查看 复制代码 boolean b2 = coll.remove("唐嫣");
System.out.println("b2:" + b2);
//删除后的集合
System.out.println("删除后的集合:"+coll);
[Java] 纯文本查看 复制代码
//public boolean isEmpty(): 判断当前集合是否为空。
//不为空返回false，为空返回true
boolean b3 = coll.isEmpty();
System.out.println("b3:"+b3);
[Java] 纯文本查看 复制代码 //public Object[] toArray(): 把集合中的元素，存储到数组中。
Object[] obj = coll.toArray();
//遍历数组
for (int i = 0; i < obj.length; i++) {
obj.toString();
System.out.println(obj);
}
[AppleScript] 纯文本查看 复制代码 //public int size(): 返回集合中元素的个数。
int size = coll.size();
System.out.println("size:"+size);
//public boolean contains(E e): 判断当前集合中是否包含给定的对象。
boolean b4 = coll.contains("迪丽热巴");
System.out.println("b4:"+b4);
//public void clear() :清空集合中所有的元素。
coll.clear();
System.out.println(coll);
}
}
- 迭代器
迭代：collection中通用的取出元素的方式，对集合进行遍历
迭代器使用步骤：
1、使用集合中的方法iterator()获取迭代器的实现对象，使用Iterator接口接收(多态)
2、使用Iterator接口中的方法hasNext判断还有没有下一个元素
3、使用Iterator接口中的方法next取出集合中的下个元素
[AppleScript] 纯文本查看 复制代码 public class IteratorTest01 {
public static void main(String[] args) {
//public Iterator iterator(): 获取集合对应的迭代器，用来遍历集合中的元素的。
//创建集合对象
Collection<String> coll = new ArrayList<>();
//添加元素
coll.add("赵丽颖");
coll.add("杨幂");
coll.add("杨颖");
coll.add("高圆圆");
coll.add("唐嫣");
//使用集合中的方法iterator()获取迭代器的实现对象，使用Iterator接口接收
Iterator<String> it = coll.iterator();
//使用Iterator接口中的方法hasNext判断还有没有下一个元素
//遍历集合，使用while循环
while (it.hasNext()){
String str = it.next();
System.out.println(str);
}
}
}
- 增强for
底层使用的也是迭代器，使用for循环的格式，简化了迭代器的书写
格式:
[AppleScript] 纯文本查看 复制代码 for(集合/数组的数据类型 变量名 ： 集合名/数组名){
...
}
import java.util.ArrayList;
public class ForTest {
public static void main(String[] args) {
demo01();
demo02();
}
//增强for遍历集合
private static void demo02() {
System.out.println("增强for遍历集合:");
ArrayList<Integer> list = new ArrayList<>();
list.add(6);
list.add(7);
list.add(8);
list.add(9);
for (int i : list) {
System.out.println(i);
}
}
//增强for遍历数组
private static void demo01() {
System.out.println("增强for遍历数组:");
int[] array = {1,2,3,4,5};
for (int i : array) {
System.out.println(i);
}
}
}
- 泛型
泛型是一种未知的数据类型，当我们不知道使用什么数据类型的时候，可以使用泛型
使用泛型的好处：
避免了类型转换的麻烦，存储的是什么类型，取出就是什么类型
把运行期异常（代码运行之后会抛出异常），提升到编译器（写代码的时候会报错）
弊端：
泛型是什么类型，只能存储什么类型的数据
定义和使用含有泛型的类：
在创建对象的时候确定泛型
[AppleScript] 纯文本查看 复制代码 public class GenericClass<E> {
private E name;
public E getName() {
return name;
}
public void setName(E name) {
this.name = name;
}
}
public class GenericClassTest {
public static void main(String[] args) {
//不写泛型默认为Object类型
GenericClass gc = new GenericClass();
gc.setName(123);
gc.setName("赵丽颖");
Object name = gc.getName();
System.out.println(name);
//创建GenericClass对象，泛型使用Integer类型
GenericClass<Integer> gc1 = new GenericClass<>();
gc1.setName(666);
Integer name1 = gc1.getName();
System.out.println(name1);
//创建GenericClass对象，泛型使用String类型
GenericClass<String> gc2 = new GenericClass<>();
gc2.setName("杨幂");
String name2 = gc2.getName();
System.out.println(name2);
}
}
含有泛型的方法：
调用方法的时候，确定泛型的类型
public class GenericMethod {
//定义一个含有泛型的方法
public <M> void method01(M m){
System.out.println(m);
}
//定义一个含有泛型的静态方法
public static <E> void method02(E e){
System.out.println(e);
}
}
package com.itheima.test01;
public class GenericMethodTest {
public static void main(String[] args) {
//创建GenericMethod对象
GenericMethod gm = new GenericMethod();
//调用含有泛型的方法的时候确定泛型类型
gm.method01("迪丽热巴");
gm.method01(123);
gm.method01(true);
gm.method02("静态方法不建议创建对象使用");
//静态方法，通过类名.方法名(参数)可以直接使用
GenericMethod.method02("高圆圆");
GenericMethod.method02(456);
GenericMethod.method02(false);
}
}
含有泛型的接口：
使用方式：
1、定义接口的实现类，实现接口，指定接口的泛型
[Java] 纯文本查看 复制代码 public class GenericInterfaceImp implements GenericInterface<E>{
...
}
2、接口使用什么泛型，实现类就使用什么泛型，类跟着接口走
就相当于定义了一个含有泛型的类，创建对象的时候确定泛型的类型
[Java] 纯文本查看 复制代码 public class GenericInterfaceImp<E> implements GenericInterface<E>{
...
}
泛型通配符：
当使用泛型类或者接口是，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。但是
一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用
此时只能接受数据，不能往该集合中存储数据
[Java] 纯文本查看 复制代码 public static void main(String[] args) {
Collection<Intger> list1 = new ArrayList<Integer>();
getElement(list1);
Collection<String> list2 = new ArrayList<String>();
getElement(list2);
}
public static void getElement(Collection<?> coll){}
//？代表可以接收任意类型，泛型不存在继承关系
受限泛型：
泛型上限：
数据类型<? extends 类> 对象名称
只能接受该类型及其子类
泛型下限：
数据类型<? super 类> 对象名称
只能接收该类型及其父类型
| 
收藏
淘帖
踩
