ArrayList ,Vector, LinkedList, 泛型(Generic) , 可变参数 ,增强for循环

ArrayList存储字符串并遍历

 
import java.util.ArrayList;
import java.util.Iterator;
 
/*
 * List的子类特点:
 * 		ArrayList:
 * 			底层数据结构是数组,查询快,增删慢
 * 			线程不安全,效率高
 * 		Vector:
 * 			底层数据结构是数组,查询快,增删慢
 * 			线程安全,效率底
 * 		LinkedList:
 * 			底层数据结构是链表,查询慢,增删快
 * 			线程不安全,效率高
 * 
 * 案例:
 * 		使用List的任意子类存储字符串或者存储自定义对象并遍历
 * 
 * ArrayList的使用。
 * 		存储字符串并遍历。
 */
public class ArrayListDemo {
	public static void main(String[] args) {
		//创建集合对象
		ArrayList al = new ArrayList();
		
		//把字符串元素添加到集合对象中
		al.add("hello");
		al.add("world");
		al.add("java");
		
		//集合遍历
		Iterator it = al.iterator();
		while(it.hasNext()){
			String s = (String)it.next();
			System.out.println(s);
		}
		System.out.println("---------------");
		
		for(int x = 0;x<al.size();x++){
			String s = (String) al.get(x);
			System.out.println(s);
		}
	}
}

Vector的特有功能

• Vector类概述: Vector 类可以实现可增长的对象数组 , Vector 是同步的。
• Vector类特有功能
  public void addElement(E obj)
  public E elementAt(int index)
  public Enumeration elements()

LinkedList的特有功能

• LinkedList类概述: List 接口的链接列表实现 , 此实现不是同步的
• LinkedList类特有功能
  public void addFirst(E e)及addLast(E e)
  public E getFirst()及getLast()
  public E removeFirst()及public E removeLast()

泛型概述和基本使用

• 泛型概述:是一种把类型明确的工作
  推迟到创建对象
  或者调用方法的时候才去明确的特殊的类型。
  参数化类型，把类型当作参数一样的传递。
• 泛型的格式 : <数据类型> 这里的数据类型只能是引用数据类型
• 泛型好处
  (1): 把运行时期的问题提前到了编译期间
  (2): 避免了强制类型转换
  (3):优化了程序设计，解决了黄色警告线
  注意：泛型只在编译期有效 但在运行期就擦除了
• 泛型基本使用

泛型类的概述及使用

• 泛型类概述: 把泛型定义在类上
• 定义格式: public class 类名<泛型类型1,…>
• 注意事项: 泛型类型必须是引用类型

案例演示:		泛型类的使用
 泛型的应用之泛型类: 就是把泛型定义在类上

格式:		public class 类名<数据类型 , ....> {}
  */
  public class ObjectTools<K> {

  private K k ;

  public K getK() {
  	return k;
  }

  public void setK(K k) {
  	this.k = k;
  }

}

泛型方法的概述和使用

A:泛型方法概述:	把泛型定义在方法上
B:定义格式:		public <泛型类型> 返回类型 方法名(泛型类型 变量名)
C:案例演示:		泛型方法的使用
public class Phone {

/**
 * 泛型方法
 */
public <E> void show(E e){
	System.out.println(e);
}
}

泛型接口的概述和使用

A:泛型接口概述:	把泛型定义在接口上
B:定义格式:		public interface 接口名<泛型类型>
C:案例演示:		泛型接口的使用
public interface Inter<T> {

public abstract void show(T t) ;
}
/**

- 泛型接口的子类:	第一种情况: 就是在定义子类的时候我们已经可以明确数据类型了
  */
  //public class InterImpl implements Inter<String> {
  //
  //	@Override
  //	public void show(String t) {
  //		System.out.println(t);
  //	}
  //
  //}

/**

- 泛型接口的子类: 第二种情况: 就是在定义子类的时候我们还不知道到底使用神马数据类型.这个时候我们就需要将这个子类也定义

- 成泛型
  */
  public class InterImpl<T> implements Inter<T>  {

  @Override
  public void show(T t) {
  	System.out.println(t);
  }

}

泛型高级之通配符

:泛型通配符<?>:		任意类型，如果没有明确，那么就是Object以及任意的Java类了
B:? extends E:			向下限定，E及其子类
C:? super E:			向上限定，E及其父类
D:案例演示:			泛型高级之通配符的基本使用
	/**
	 * 泛型如果明确了数据类型以后,那么要求左右两边的数据类型必须一致
	 */
	Collection<Object> col1 = new ArrayList<Object>() ;
	Collection<Object> col2 = new ArrayList<Animal>() ;//报错

	// ? 表示任意的数据类型
	Collection<?> col5 = new ArrayList<Object>() ;
	Collection<?> col6 = new ArrayList<Animal>() ;

	// ? extends E : 向下限定	, ? 表示的是E或者E的子类
	//		Collection<? extends Animal> col9 = new ArrayList<Object>() ;//报错
		Collection<? extends Animal> col10 = new ArrayList<Animal>() ;
		Collection<? extends Animal> col11 = new ArrayList<Dog>() ;
			// ? super E:  向上限定 , ? 表示的是E或者E的父类
	Collection<? super Animal> col13 = new ArrayList<Object>() ;
	Collection<? super Animal> col14 = new ArrayList<Animal>() ;
	//		Collection<? super Animal> col15 = new ArrayList<Dog>() ;//报错

增强for的概述和使用

• 增强for概述
  简化数组和Collection集合的遍历
• 格式：
  for(元素数据类型 变量 : 数组或者Collection集合) {
  使用变量即可，该变量就是元素
  }
• 好处和注意事项
  简化遍历
  注意事项：增强for的目标要判断是否为null

可变参数的概述和使用

• 可变参数概述: 定义方法的时候不知道该定义多少个参数
• 格式: 修饰符 返回值类型 方法名(数据类型… 变量名){}
• 注意事项：
  a: 这里的变量其实是一个数组
  b: 如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个

	// 可变参数
public static int add(int... a){
	
	// 定义一个累加变量
	int sum = 0 ;
	
	for(int s : a ){
		sum += s ;
	}
	
	return sum;
}

集合嵌套之ArrayList嵌套ArrayList

public class MyTest {
    public static void main(String[] args) {
        //A:
        //需求：
        //我们班有学生，每一个学生是不是一个对象。所以我们可以使用一个集合表示我们班级的学生。ArrayList<Student>
        //但是呢，我们旁边是不是还有班级，每个班级是不是也是一个ArrayList<Student>。
        //而我现在有多个ArrayList<Student>。也要用集合存储，怎么办呢 ?
        //        集合嵌套之ArrayList嵌套ArrayList

        ArrayList<Student> javaList = new ArrayList<>();
        javaList.add(new Student("张三1", 23));
        javaList.add(new Student("张三2", 23));
        javaList.add(new Student("张三3", 23));

        ArrayList<Student> webList = new ArrayList<>();
        webList.add(new Student("张三4", 23));
        webList.add(new Student("张三5", 23));
        webList.add(new Student("张三6", 23));

        ArrayList<Student> linuxList = new ArrayList<>();
        linuxList.add(new Student("张三7", 23));
        linuxList.add(new Student("张三8", 23));
        linuxList.add(new Student("张三9", 23));

        //创建一个大的集合，大的集合放小的集合
        ArrayList<ArrayList<Student>> maxList = new ArrayList<>();
        maxList.add(javaList);
        maxList.add(webList);
        maxList.add(linuxList);

        //
        //遍历：普通for循环
        for (int i = 0; i < maxList.size(); i++) {
            ArrayList<Student> minList = maxList.get(i);
            for (int j = 0; j < minList.size(); j++) {
                Student student = minList.get(j);
                System.out.println(student.getName() + "===" + student.getAge());
            }

        }
        System.out.println("----------------------------------------------------------");
        //新式for循环遍历
        for (ArrayList<Student> students : maxList) {
            for (Student student : students) {
                System.out.println(student.getName() + "===" + student.getAge());
            }
        }


    }
}

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}