Collection接口:
定义的是所有单列集合中共性的方法
所有的单列集合都可以使用这些共性的方法
没有带索引的方法(不能用for循环遍历)
List接口:
1.有序的集合(存储和取出元素的顺序是相同的)
2.允许存储重复的元素
3.有索引,可以用普通的for循环进行遍历
Set接口:
1.不允许存储重复的元素
2.没有索引,不能使用普通的for循环
参考文档
学习集合的目标:
1.会使用集合存储数据
2.会遍历结合,把数据取出来
3.掌握每种集合的特性
/Collection常用方法
public class CollTest01 {
public static void main(String[] args) {
Collection<String> coll=new ArrayList<>();
//使用方法,add
coll.add("迪丽热巴");
coll.add("古力拉扎");
coll.add("马尔扎哈");
coll.add("赵丽颖");
System.out.println(coll);
System.out.println(coll.contains("赵丽颖"));
System.out.println(coll.size());
//toArray输出后foreach循环
for (Object o : coll) {
System.out.print(o+" ");
}
System.out.println("++++++++");
//创建迭代器
/*1.使用集合中的方法: Iterator<E> iterator(), 获取迭代器的对象
注意:迭代器接口的泛型类型Iollection接口的泛型类型要保持- -致
*/
Iterator<String> it = coll.iterator();
/*2. boolean hasNext( )
E next()返回迭代中的下一一个元素。
启始是-1
*/
while (it.hasNext()){
String next = it.next();
System.out.println(next);
}
coll.clear();
System.out.println();
System.out.println(coll.isEmpty());
}
}
使用泛型与不使用泛型的区别
使用泛型:
弊端: .泛型是什么类型,只能存储什么类型
好处:1)把运行时期的异常,提升到J编译时期(写代码的时候就会保存, 可以及时修改)
好处2):元素类型统一,避免了元素类型转换的麻烦
不使用泛型:
弊端:不安全,会发生异常
好处:集合不使用泛型,默认存储类型是object类型,就可以存储任意数据类型
iterator迭代器的使用
public class CollTest02 {
public static void main(String[] args) {
Collection<String> coll=new ArrayList<>();
//使用方法,add
coll.add("迪丽热巴");
coll.add("古力拉扎");
coll.add("马尔扎哈");
coll.add("赵丽颖");
// System.out.println(coll);
Iterator<String> it = coll.iterator();
while (it.hasNext()){
String next = it.next();
System.out.println(next);
}
/* while (coll.iterator().hasNext()){
System.out.println( coll.iterator().next());
}*/
}
}
增强for循环
//增强for循环的使用方法
public class CollTest02 {
public static void main(String[] args) {
Collection<String> coll=new ArrayList<>();
//使用方法,一般用于数组和集合
coll.add("迪丽热巴");
coll.add("古力拉扎");
coll.add("马尔扎哈");
coll.add("赵丽颖");
for (String s : coll) {
System.out.println(s);
}
}
}
定义和使用含有泛型的类
package demo02;
/*/*
自定义泛型类: ( 模拟ArrayList<E>)
public cLass ArrayList<E>{
public booLean add(E e) {}
}
泛型是一- 个未知的数据类型,当我们不知道用什么数据类型的时候,可以使用泛型
泛型可以接收任意数据类型,Integer, string , Student....
自定义的泛型类,在创建对象的时候确定泛型类型即可
*/
public class GeTest01<E> {
E name;
public E getName() {
return name;
}
public void setName(E name) {
this.name = name;
}
}
public class GeTest02 {
public static void main(String[] args) {
GeTest01<String> g= new GeTest01<>();
g.setName("张三");
System.out.println(g.getName());
}
}
自定义泛型方法
自定义泛型方法:泛型要定义在修饰符和返回值类型之间
格式:
修饰符<代表泛型的变量>返回值类型方法名(参数列表(使用泛型) ){ }
z注:含有泛型的方法,是在方法被调用的时候确定泛型的数据类型
传递什么类型的参数,泛型就是什么类型
public class GenericMethod {
public <M> void method(M m){
System.out.println(m);
}
}
public class Test {
public static void main(String[] args) {
GenericMethod g = new GenericMethod();
g.method(1);
g.method("什么鬼");
g.method(1.3);
}
}
自定义泛型接口
含有泛型接口,第一-种使用方式:
定义接口实现类,实现接口,直接指定接口的泛型
public interface Iterator {
}
public final class Scanner implements Iterator{
public String next() {}
}
含有泛型接口,第二种使用方式:
接口使用什么泛型,实现类就使用什么泛型,类跟着接口走
public interface List {
boolean add(E e);
public E get(int index) {}
public class ArrayList implements List{
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increme
eLementData[size++] = e;
return true;
}
public E get(int index) {
rangeCheck(index);
return elementData( index);
}
}
泛型的通配符: .
? :表示任意的数据类型
使用方式:
不能创建对象使用
只能作为方法的参数使用
定义一一个方法能遍历所有类型的ArrayList集合
此时我们不知道ArrayList集合泛型中放的是什么数据类型,
我们就可以用泛型通配符?来接收这个数据类型
package demo03;
import java.util.ArrayList;
import java.util.Iterator;
public class FanTest01 {
public static void main(String[] args) {
ArrayList<String> str1=new ArrayList<>();
str1.add("金");
str1.add("木");
str1.add("水");
str1.add("火");
str1.add("土");
ArrayList<Integer> str2=new ArrayList<>();
str2.add(1);
str2.add(2);
str2.add(3);
printArray(str1);
printArray(str2);
}
public static void printArray(ArrayList<?> list){
Iterator<?> it = list.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
}
}