JavaSE基础集合

List集合的子实现类的特点:

ArrayList:从线程安全问题来看:线程不安全的,不同步,执行效率高
Vector:
底层数据结构是数组的形式,查询快,增删慢
从线程角度看:线程安全的类,同步,执行效率低
LinkedList:
底层数据结构是链接列表,特点:查询慢,增删快
从线程角度看:线程不安全的一个类,不同步,执行效率高

如果实现多线程程序,一般要是安全的类:
StringBuffer,Vector<E>,hashtable<K,V>

synchronized(同步锁对象){
代码;
}

如果在一般的需求中没有指明使用集合去完成,都默认采用ArrayList，如果需求中要考虑线程安全,那么使用Vector集合!

1.ArrayList

ArrayList是List的子实现类，元素可以重复，存储和取出一致。

/**
 * 
 */
package org.zst.ArrayList;

import java.util.ArrayList;
import java.util.Iterator;

/**
 * @author：zsyht
 * @date：2017-11-15上午7:38:27
 */
public class ArrayListDemo {
	public static void main(String[] args) {
		//创建List集合对象
		ArrayList array = new ArrayList();
		//添加元素
		array.add("ssy");
		array.add("ssy");
		array.add("zst");
		array.add("nice");
		array.add("nice");
		//获取迭代器
		Iterator it =array.iterator();
		//遍历元素
		while(it.hasNext()){
			String s = (String) it.next();
			System.out.println(s);
		}
	}

}

2.vector

特有功能：

public void  addElement(E  obj):添加功能

public Enumeration<E>  elements():获取功能

Enumeration<E>接口:向量的组件枚举有两个方法：
boolean hasMoreElements()：是否有下一个可以获取的元素  相当于hasNext()

Object  nextElements():获取下一个元素 相当于next()

/**
 * 
 */
package org.zst.Vector;

import java.util.Enumeration;
import java.util.Vector;

/**
 * @author：zsyht
 * @date：2017-11-15上午7:54:49
 */
public class VectorDemo {
	public static void main(String[] args) {
		//创建一个vector集合
		Vector v = new Vector();
		//添加元素
		v.addElement("hello");
		v.addElement("ssy");
		v.addElement("ssy");
		v.addElement("zst");
		
		Enumeration e =v.elements();
		while(e.hasMoreElements()){
			String s = (String) e.nextElement();
			System.out.println(s);
		}	
	}
}

3.LinkedList

特有功能：

添加功能：

public  void   addFirst():将指定元素插入此列表开头

public  void   addLast(): 将指定元素添加到此列表的结尾

获取功能：

public  Object  getFirst():返回此列表的第一个元素

public  Object  getLast():返回此列表的最后一个元素

删除功能：

public  Object  removeFirst():移除并返回此列表的第一个元素

public  Object  removeLast():移除并返回此列表的第一个元素

/**
 * 
 */
package org.zst.linkedlist;

import java.util.LinkedList;

/**
 * @author：zsyht
 * @date：2017-11-15下午7:24:16
 */
public class LinkedListDemo {
	public static void main(String[] args) {
		LinkedList l = new LinkedList();
		//添加元素
		l.add("枯藤");
		l.add("老树");
		l.add("昏鸦");
		l.addFirst("小桥");
		Object obj =l.getFirst();
		Object obj2 =l.getLast();
		
		System.out.println("removeFirst:"+l.removeFirst());
		System.out.println("removeLast:"+l.removeLast());
		
		System.out.println(obj);
		System.out.println(obj2);
		System.out.println(l);
	
	}
}

泛型的引入（jdk5）：把数据类型的明确工作提前到了创建对象或是调用方法的时期明确的一种特殊类型，参数化类型

格式：  <引用类型>：泛型只能存放引用类型

好处：a、将运行时期异常提前到了编译时期异常

          b、解决了黄色警告线问题

          c、获取数据的时候不用强制类型转换

泛型的应用：一般情况下泛型可以应用在接口，类，或者方法上；主要用在集合比较多。

/**
 * 
 */
package org.zst.ArrayList;


import java.util.ArrayList;
import java.util.Iterator;


/**
 * @author：zsyht
 * @date：2017-11-15下午9:26:09
 */
public class Demo2 {
	public static void main(String[] args) {
		ArrayList<String> a = new ArrayList<String>();
		//解决了黄色警告线问题
		a.add("古道");
		a.add("西风");
		a.add("瘦马");
		Iterator<String> it =a.iterator();
		while(it.hasNext()){
			String s  =it.next();
			System.out.print(s+",");
		}	
	}
}

泛型定义在类上，提高程序的安全性

/**
 * 
 */
package org.zst.fx;

/**
 * @author：zsyht
 * @date：2017-11-16上午10:35:26
 */
public class Demo {
	public static void main(String[] args) {
		ObjectTool<String> ot = new ObjectTool<String>();
		ot.setObj("孙思远");
		//Integer i = ot.getObj();  //由于类中加入了泛型，在实际测试中，给定了数据类型，获取数据的时候就必须用该类型来接收，否则错误，编译不通过/
		String str = ot.getObj();
		System.out.println("姓名："+str);
		
		
		ObjectTool<Integer>  ot2 = new ObjectTool<Integer>();
		ot2.setObj(19);
		Integer i = ot2.getObj();
		System.out.println("年龄："+i);
		
	}
}

泛型定义在方法上：

/**
 * 
 */
package org.zst.fx2;

/**
 * @author：zsyht
 * @date：2017-11-16上午10:48:15
 */
public class ObjectTool<T> {
	//定义几个成员方法
	public <T> void show(T t){
		System.out.println(t);
	}
}

/**
 * 
 */
package org.zst.fx2;

/**
 * @author：zsyht
 * @date：2017-11-16上午10:50:51
 */
public class Demo {
	public static void main(String[] args) {
		ObjectTool ot = new ObjectTool();
		//可是接受任意数据类型
		ot.show("孙思远");
		ot.show(100);
		ot.show(false);
	}
}

泛型定义在接口上：

第一种情况：接口的子实现类已经知道传递的是什么数据类型

/**
 * 
 */
package org.zst.fx3;

/**
 * @author：zsyht
 * @date：2017-11-16上午11:04:38
 */
public interface Inter<T> {
	public abstract void show(T t);
}

/**
 * 
 */
package org.zst.fx3;

/**
 * @author：zsyht
 * @date：2017-11-16上午11:05:59
 */
public class InterImpl<String> implements Inter<String> {
	@Override
	public void show(String t) {
		System.out.println(t);
		
	}

}

/**
 * 
 */
package org.zst.fx3;

/**
 * @author：zsyht
 * @date：2017-11-16上午11:07:56
 */
public class Demo {
	public static void main(String[] args) {
		Inter<String> i = new InterImpl();
		i.show("hello");
	}
}

第二种情况：接口的子实现类在实现接口的时候不知道具体数据类型是什么

/**
 * 
 */
package org.zst.fx3;

/**
 * @author：zsyht
 * @date：2017-11-16上午11:05:59
 */
public class InterImpl<T> implements Inter<T> {
	@Override
	public void show(T t) {
		System.out.println(t);	
	}
}

/**
 * 
 */
package org.zst.fx3;

/**
 * @author：zsyht
 * @date：2017-11-16上午11:07:56
 */
public class Demo {
	public static void main(String[] args) {
		Inter<Integer> i = new InterImpl<Integer>();
		i.show(19);
		Inter<String> i2= new InterImpl<String>();
		i2.show("孙思远");
	}
}

  泛型的高级:通配符
 <?> :可以是任意类型,包括Object类型以及任意的Java类
 <? extends E>:向下限定,E类型以及E类型的子类
 <? super E>:向上限定,E类型以及E类型的父类

/**
 * 
 */
package org.zst.fx3;

import java.util.ArrayList;
import java.util.Collection;

/**
 * @author：zsyht
 * @date：2017-11-16上午11:22:00
 */
public class Demo2 {
		
		public static void main(String[] args) {
			
			//创建Collection集合的对象
			//最起码:前后的数据类型保持一致
//			Collection<Object> c1 = new ArrayList<Animal>() ;
//			Collection<Object> c2 = new ArrayList<Cat>() ;
//			Collection<Object> c3 = new ArrayList<Dog>() ;
			Collection<Object> c3 = new ArrayList<Object>() ;
			
			
			// <?> :可以是任意类型,包括Object类型以及任意的Java类
			Collection<?> c4 = new ArrayList<Object>() ;
			Collection<?> c5 = new ArrayList<Animal>() ;
			Collection<?> c6 = new ArrayList<Cat>() ;
			Collection<?> c7 = new ArrayList<Dog>() ;
			
			//<? extends E>:向下限定,E类型以及E类型的子类
			Collection<? extends Object> c8 = new ArrayList<Object>() ;
			Collection<? extends Animal> c9 = new ArrayList<Animal>() ;
//			Collection<? extends Animal> c10 = new ArrayList<Object>() ;
			Collection<? extends Object> c11 = new ArrayList<Cat>() ;
			
			//<? super E>:向上限定,E类型以及E类型的父类
			Collection<? super Animal> c12 = new ArrayList<Object>() ;
			Collection<? super Animal> c13 = new ArrayList<Animal>() ;
//			Collection<? super Animal> c14 = new ArrayList<Dog>() ;
		}
	}

	//自定义两个类
	class Animal{
		
	}

	class Cat extends Animal{
		
	}
	class Dog extends Animal{
	
	}

增强for循环：

书写格式：

  for(集合或数组中的数据类型  变量名：集合或数组的对象名){

           输出变量名；

}

增强for循环的弊端：遍历数组或集合的时候，数组或集合的对象不能为null；如果对象为空，一般要加上非空判断

增强for循环的出现就是为了替代迭代器遍历集合的，开发中就使用增强for循环遍历元素。