day13总结：list的三个子集合类，泛型；可变参数，静态导入，增强for；Array类的asList（）方法

1.  *泛型:将明确的集合类型的工作推迟到了创建对象或者调用方法的时候,属于一种参数化类型,可以作为参数传递；泛型的引出可以提供程序的安全性!
    1）  泛型的好处:
          1)将运行时期异常提前到了编译时期
2)优化了设计,解决了黄色警告线问题
3)避免了强制类型转换

 * 使用ArrayList集合存储自定义对象并遍历,加入泛型

public class GenericDemo2 {

public static void main(String[] args) {

//创建集合对象
ArrayList<Student> array = new ArrayList<Student>() ;  //=号右边的泛型:泛型推断

//创建学生对象
Student s1 = new Student("王昭君",25) ; 
Student s2 = new Student("西施",27) ; 
Student s3 = new Student("杨贵妃",25) ; 
Student s4 = new Student("貂蝉",28) ; 

//添加到集合中
array.add(s1) ;
array.add(s2) ;
array.add(s3) ;
array.add(s4) ;

//获取迭代器
Iterator<Student> it = array.iterator() ;
while(it.hasNext()) {
Student s = it.next() ;
System.out.println(s.getName()+"----"+s.getAge());
}

System.out.println("------------------");

//普通for循环
for(int x = 0 ; x < array.size() ; x ++) {
Student s = array.get(x) ;
System.out.println(s.getName()+"---"+s.getAge());
}
}

}

2）如何提高程序的安全性：

//把泛型定义在类上,提高程序安全性，解决了向下类型转换出现的问题:ClassCastException

public class ObjectTool<T> {


private T obj ;

public T getObj() {
return obj ;
}

public void setObj(T obj) {
this.obj = obj ;
}
}

public class ObjectToolDemo {

public static void main(String[] args) {

//创建ObjectTool对象
ObjectTool<String> ot = new ObjectTool<String>() ;

//赋值
ot.setObj(new String("高圆圆"));
String s = ot.getObj() ;
System.out.println("姓名是:"+s);

// ot.setObj(new Integer(27)); 直接隐藏的问题解决了
System.out.println("---------------");

ObjectTool<Integer> ot2 = new ObjectTool<Integer>() ;
ot2.setObj(new Integer(27));
// ot2.setObj(new String("高圆圆"));
Integer i = ot2.getObj() ;
System.out.println("年龄是:"+i);
}
}

3）

//把泛型定义在方法上：

//public class ObjectTool<T> {
//
// //提供一些成员方法
// /*public void show(String s) {
// System.out.println(s);
// }
//
// public void show(Integer i) {
// System.out.println(i);
// }
//
// public void show(boolean b) {
// System.out.println(b);
// }*/
//
// public void show(T t) {
// System.out.println(t);
// }
public class ObjectTool{

//泛型是可以在方法上定义的
public <T> void show(T t) {
System.out.println(t);
}

}

public class ObjectToolDemo {

public static void main(String[] args) {

//创建ObjectTool类的对象
/*ObjectTool ot = new ObjectTool() ;
ot.show("hello");
ot.show(100);
ot.show(true);*/

//在类上定义了泛型,方法的参数T类型去接收
// ObjectTool<String> ot = new ObjectTool<String>() ;
// ot.show("hello");
// ObjectTool<Integer> ot2= new ObjectTool<Integer>() ;
// ot2.show(100);
// System.out.println("---------");

//可以将泛型定义在类上,可不可以在类上不定义泛型,将泛型应用在方法上?
//是可以在方法上定义的!
ObjectTool ot = new ObjectTool() ;
ot.show("hello");
ot.show(true);
ot.show(100);
}

}

4）

//把泛型定义在接口上：

public interface Inter<T> {

//接口中变量是常量: public static final  int num ;

public abstract void show() ; //抽象方法

}

//泛型的应用:在接口中,类中,方法上应用,在集合中应用最多!

//接口中泛型,子实现类的第一种情况,就是已经知道是什么类型了
//public class InterImpl implements Inter<String> {
//
// @Override
// public void show() {
// System.out.println("hello");
// }
//
//}

//第二种情况,就是不知道具体的类型是什么
public class InterImpl<T> implements Inter<T>{

@Override
public void show() {
System.out.println("hello");
}

}

//测试类
public class InterDemo {
public static void main(String[] args) {

//第一种情况的测试
//创建接口的子实现类对象
Inter<String> i = new InterImpl() ;
i.show();

System.out.println("---------------------");

//第二种情况
Inter<Integer> i2 = new InterImpl<Integer>();
i2.show() ;

Inter<String> i3 = new InterImpl<String>() ;
i3.show();

}
}

5） 泛型高级(通配符)：
 *<?>  :代表任意类型Object类型,或者任意的Java类 
 *<? extends E>:向下限定,E的子类或者E这个类型
 *<? super E>:向上限定,E及其他的父类
 *
 */
public class GenericDemo {

public static void main(String[] args) {

//创建集合对象,泛型如果明确的情况下,前后必须保持一致
Collection<Object> c1 = new ArrayList<Object>() ;
// Collection<Object> c2 = new ArrayList<Cat>() ;
// Collection<Object> c3 = new ArrayList<Animal>() ;


//<?>  :代表任意类型Object类型,或者任意的Java类 
Collection<?> c4 = new ArrayList<Object>() ;
Collection<?> c5 = new ArrayList<Animal>() ;
Collection<?> c6 = new ArrayList<Dog>() ;
Collection<?> c7= new ArrayList<Cat>() ;

// <? extends E>:向下限定,E的子类或者E这个类型
Collection<? extends Object> c8 = new ArrayList<Object>() ;
Collection<? extends Object> c9 = new ArrayList<Animal>() ;
Collection<? extends Object> c10 = new ArrayList<Cat>() ;
// Collection<? extends Aninal> c11 = new ArrayList<Object>() ;错误的

// <? super E>:向上限定,E及其他的父类
// Collection<? super Animal> c12 = new ArrayList<Cat>() ;错误的
Collection<? super Animal> c13 = new ArrayList<Animal>() ;
Collection<? super Animal> c14 = new ArrayList<Object>() ;

}
}


class Animal{

}
class Cat extends Animal {

}


class Dog extends Animal{

}

2.lsit集合的三个子实现类：ArrayList  Vector  LinkedList

 1）Vector集合
 * 底层是一种可增长对象数组,查询快,增删慢
 * 线程安全,同步,执行效率高
 * 
 * 特有功能:
 * public void addElement(Object obj)------->add(Object obj)
 * public Enumeration elements():返回此向量的枚举--->相当于:public Iterator iterator()
 * boolean hasMoreElements()  --->boolean hasNext() ;
 *         Object nextElement()  --->Object next() ;
 *
 */
public class VectorDemo {

public static void main(String[] args) {

//创建集合对象
Vector v = new Vector() ;

//添加元素
v.addElement("hello"); 
v.addElement("world");
v.addElement("java");

//遍历
//获取Enumeration :向量的枚举
Enumeration en = v.elements() ;
while(en.hasMoreElements()) {
String s = (String)en.nextElement() ;
System.out.println(s);
}
}

}

2）*LinkedList集合的特点:
 * 底层是一种链表实现,查询慢,增删快
 * 线程不安全的,不同步,执行效率高
 *
 *特有功能:
 * 添加功能
 * addFirst(Object e):将指定的元素插入到列表的开头
 * public Object removeLast()
 * addLast(object e):将指定的元素添加到列表末尾
 * 获取功能:
 * getFirst():获取列表第一个元素
 * getLast():获取列表第二个元素
 
public class LinkedListDemo {

public static void main(String[] args) {

//创建LinkedList集合对象
 * 删除功能
 * public Object removeFirst()移除并返回此列表的第一个元素。
LinkedList link = new LinkedList() ;

//添加元素
link.add("hello"); 
link.add("world"); 
link.add("java"); 
System.out.println("link:"+link);

//addFirst(Object e):将指定的元素插入到列表的开头
// link.addFirst("android");
// System.out.println("link:"+link);
// link.addLast("mysql");
// System.out.println(link);

//getFirst():获取列表第一个元素
// System.out.println(link.getFirst());
// System.out.println(link.getLast());

//public Object removeFirst()移除并返回此列表的第一个元素。 
System.out.println("removeFirst():"+link.removeFirst());
System.out.println(link);
//public Object removeLast()
System.out.println(link.removeLast());
}

}

3）

* 需求:使用集合ArrayList存储自定义对象(Student),去除重复的对象(成员变量的值一样,看成一个人)
 * @author Administrator
 * 
 * 问题:按照存储字符串(新建集合的思想)的形式来去存储自定义对象,发现自定义对象并没有去重,为什么?
 * contains方法底层依赖于equals方法
 * equals方法默认比较的是地址值,如果想让equals()方法比较他们的内容是否相同,需要重写equals(),也就意味着存储自定义类,必须重写
 * equals()方法,这样才能比较的是这些对象的内容是否相同
 */
public class ArrayListTest3 {


public static void main(String[] args) {

//创建一个ArrayList集合
ArrayList array = new ArrayList() ;

//创建4个学锁对象
Student s1 = new Student("高圆圆", 27);
Student s2 = new Student("文章", 29);
Student s3 = new Student("王力宏", 30);
Student s4 = new Student("高圆圆", 27);
Student s5 = new Student("高圆圆", 29);

array.add(s1) ;
array.add(s2) ;
array.add(s3) ;
array.add(s4) ;
array.add(s5) ;

//创建一个新集合
ArrayList newArray = new ArrayList() ;

//遍历旧集合
Iterator it = array.iterator() ;
while(it.hasNext()) {
Student s = (Student)it.next() ;

//判断,新集合中是否包含
if(!newArray.contains(s)) {
newArray.add(s) ;
}
}

//遍历新集合
Iterator it2 = newArray.iterator() ;
while(it2.hasNext()) {
Student s= (Student)it2.next();
System.out.println(s.getName()+"---"+s.getAge());
}
}

}

@Override//重写的equals（）方法
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;

}

3.JDK5后的新特性：

    增强for,静态导入,可变参数,泛型,自动拆装箱...
1）增强for循环的格式
 * for(数据大类型  变量名 : 数组或者集合对象名){
 * 输出变量即可!
 * }

 * 增强for的出现时替代迭代器的,所以在遍历集合或者遍历数组就可以使用增强for去完成
 

 * 增强for循环的弊端:如果集合的对象是null,如果再次对集合操作,就会出现异常；所以要对集合进行判断,非空判断解决

 *ArrayList集合存储自定义对象并遍历方式：

 * Iterator iterator() ;
 * listIterator listiterator();(可以不写)
 * 普通for循环:size()/get(int index)
 * 增强for循环

2） 可变参数:当一个方法的参数个数不确定的时候,要使用可变参数
 * 格式:
修饰符 返回值类型  方法名(数据类型...变量名){...}

 * 注意:
1)变量名:看成一个数组
2)使用的时候数据类型...

 * 注意:根据具体的需求去完成,一般情况,知道有这个特性就可以了

 *求数据之和
public class ArgsDemo {


public static void main(String[] args) {
int a = 10 ;
int b = 20 ;
int result = sum(a,b) ;
System.out.println("result:"+result);

int c = 30 ;
int result2 = sum(a,b,c);
System.out.println("result2:"+result2);

int d = 40 ;
int result3 = sum(a,b,c,d);
System.out.println("result3:"+result3);

//当我们的参数不确定的情况下,就可以使用jdk5一个特性:可变参数
System.out.println(sum(a,b,c,d,50));
}

//定义一个参数不确定的方法,通过可变参数操作
public static int sum(int...a) {
//求和:将a是多个参数的,看成数组

//先定义最终结果变量
int result = 0 ;
//增强for遍历可变参数a
for(int n :a) {
result += n ;
}
return result;
}

//求两个数据之和
/* public static int sum(int a ,int b) {
return a +b ;
}

public static int sum(int a,int b,int c) {
return a+b +c ;
}

public static int sum(int a,int b,int c,int d) {
return a+b +c +d ;
}*/

}

3）

* 针对数组操作的工具类:Arrays,提供了一个方法:
 * public static <T> List<T> asList(T... a) :将数组转换成固定大小的集合
 *注意:如果使用此方法,那么集合的长度不可变

public class ArraysDemo {

public static void main(String[] args) {

//定义数组:
/*String[] str = {"hello","world","java"} ;

//将数组转换成固定大小的集合
List<String> list = Arrays.asList(str) ;*/

List<String> list = Arrays.asList("hello","world","java") ;

//添加元素
//list.add("javaee") ;// java.lang.UnsupportedOperationException :集合固定的,长度是固定的

// list.remove("world") ;
list.set(1, "javaee"); //修改集合中的元素内容
//增强for
for(String s:list) {
System.out.println(s);
}
}

}

4）* ArrayList父类中的toString()的源码分析

 *  public String toString() {
        Iterator<E> it = iterator();  //this.iterator();
        if (! it.hasNext()) //迭代器遍历,如果没有元素可以迭代,返回"[]"
            return "[]";


        StringBuilder sb = new StringBuilder(); //构造了字符串缓冲区对象
        sb.append('['); //[
        for (;;) {
            E e = it.next();
            sb.append(e == this ? "(this Collection)" : e);
            if (! it.hasNext()){
            return sb.append(']').toString(); //取到集合中的最后一个元素拼接右"]"将元素转换String
            }else{
            sb.append(',').append(' ');
            }  
        }

    }

5）静态导入:Jdk5一个新特性
 * 特点:
1)前提是该方法必须是静态的
2)导入到的一个方法的级别

 *静态导入的格式:
import static 包名.类名.方法名;

 *import static java.util.ArrayList.add;   方法必须是静态方法
 *
 *常用类中哪个类中静态方法最多:Math

 *之前导包:java.util.Scanner;   导入到类的级别

import static java.lang.Math.abs; //导入到方法的级别
import static java.lang.Math.pow;
public class ImportStaticDemo {

public static void main(String[] args) {
System.out.println(Math.abs(-100));
System.out.println(Math.pow(2,3));
//可以使用带前缀的方式
System.out.println(java.lang.Math.abs(-100));

System.out.println("-------------------------");

//在测试,直接写方法名,前提静态导入
// System.out.println(abs(-100));

System.out.println(java.lang.Math.abs(-100));
System.out.println(pow(2,3));

//本身当前的某个类中的方法名和需要被静态导入的方法名一样,必须加上前缀

}

//Date ---->有两个包下  java.util.Date java.sql.Date

public static void abs() {

}

}

4：*集合的嵌套遍历

有一个Java基础班,里面有很多学生,把一个班级集合:ArrayList<Student>，不止一个Java基础班,这个时候就定义大集合:ArrayList<ArrayList<Student>>。


有三个基础班,分别遍历每一个班里面学生信息:(name,age) 
 *
 */
public class ArrayListTest {

public static void main(String[] args) {

//创建一个大的集合
ArrayList<ArrayList<Student>> bigArrayList = new ArrayList<ArrayList<Student>>() ;

//创建第一个班的集合对象
ArrayList<Student> firstArray = new ArrayList<Student>() ;
//创建学生对象
Student s1 = new Student("曹操",35) ;//后知后觉
Student s2 = new Student("诸葛亮", 29);//先知先觉
Student s3 = new Student("蒋干", 30) ;//不知不觉

//给第一个班添加元素
firstArray.add(s1) ;
firstArray.add(s2) ;
firstArray.add(s3) ;

//将第一个集合添加到大集合中
bigArrayList.add(firstArray) ;

//创建第二个班集合对象
ArrayList<Student> secondArray = new ArrayList<Student>() ;
Student s11 = new Student("宋江",38) ;
Student s22 = new Student("鲁智深", 29);
Student s33 = new Student("武松", 30) ;

secondArray.add(s11) ;
secondArray.add(s22) ;
secondArray.add(s33) ;

//添加到大集合
bigArrayList.add(secondArray) ;

//创建第三个集合对象
ArrayList<Student> thirdArray = new ArrayList<Student>() ;
Student s111 = new Student("高圆圆",38) ;
Student s222 = new Student("唐嫣", 29);
Student s333 = new Student("刘若英", 30) ;

thirdArray.add(s111) ;
thirdArray.add(s222) ;
thirdArray.add(s333) ;
//添加到集合
bigArrayList.add(thirdArray) ;

//增强for遍历:大集合
for(ArrayList<Student> array: bigArrayList) {
for(Student s:array) {
System.out.println(s.getName()+"---"+s.getAge());
}
}



}
}