java基础--List

List 实例

public class ArrayList1 {
	public static void main(String[] args) {
		List list= new ArrayList();
		list.add("中国");
		list.add("美国");
		list.add("英国");
		list.add("俄罗斯");
		list.add("日本");
		System.out.println(list);
		if(list.isEmpty()){
			System.out.println("true");//不存在是true
		}else{
			System.out.println("false");
		}
		System.out.println(list.get(2));//用索引得到的值
		System.out.println(list.remove(3)+"//用索引删除");
		System.out.println(list.contains("日本")+"//用值查找");
		
		
	} 

 public static void main(String[] args) {
                // 创建List集合对象
                List<String> list = new ArrayList<String>();
                list.add("李哥,男,1981-1-1");// 添加数据到集合对象
                list.add("小陈,女,1981-1-1");
                list.add("小刘,男,1981-1-1");
                list.add("小张,男,1981-1-1");
                list.add("小董,男,1981-1-1");
                list.add("小吕,男,1981-1-1");
                for (String info : list) {// 遍历学生集合对象
                        System.out.println(info);// 把学生信息添加到表格的行
                }
        }

List的添加与删除

//JDK5的新特性：自动拆装箱，泛型，增强for，静态导入，可变参数，枚举
public class ArraylistAddandDel {
	public static void main(String[] args) {
		List list=new ArrayList();
		list.add("hello");//添加元素
		list.add("world");
		list.add("java");
		list.add("你好");
		list.add("hello");//添加元素
		list.add("world");
		list.add("java");
		list.add("你好");
		list.add("hello");//添加元素
		list.add("world");
		list.add("java");
		list.add("你好");
		list.add("hello");//添加元素
		list.add("world");
		list.add("java");
		list.add("你好");
		System.out.println("*********使用迭代器删除当前的重复的元素********");
		List li=new ArrayList();//重新创建新的对象
		Iterator it=list.iterator();//使用迭代器
		while(it.hasNext()){
			String str=(String)it.next();
			if(!li.contains(str)){//进行判断是否包含元素，如果不包含就添加
				li.add(str);//contains();方法的底层是equals()方法，而对象类没有equals(),
			}//它默认的是object()里的equals()方法，而equals()方法比较的是地址，new的是新对象的地址不同
		}//所以如果对象使用，必须在自身类里重写equals()方法；
		
			for(int i=0;i<li.size();i++){//用for循环遍历
				String s=(String)li.get(i);
				System.out.println(s);
			}
			System.out.println("&&&&&&&&&&&&&&用for循环删除当前的重复的元素&&&&&&&&&&&&&&&&&&&7");
			for(int x=0;x<list.size()-1;x++){//可以利用选择排序，用0索引和相邻的比较如果有相同的就干掉
				for(int y=x+1;y<list.size();y++){
					if(list.get(x).equals(list.get(y))){
						list.remove(y);//如果最后一个元素有三个相同那list.remove(y);只删除一个
						y--;//所以要在用y--在返回判断删除
					}
				}
			}
			Iterator ite=list.iterator();
			while(ite.hasNext()){
				String st=(String)ite.next();
				System.out.println(st);
			}
			
	}
}

实例2

/***1.接口collection在java.uilt包中
 * 2接口collection接口表示一组对象分三个接口
 *	A.list接口,实现类分为[长度可变，有序[存储顺序与取出一致]，可重复]
 *		a.ArrayList（底层用数组实现的List,查询效率高，增删效率低，线程不安全）
 *				可以存储字符串也可以遍历
 *      ArrayList 有特有的迭代器，ListIterator可以正顺序与饭顺序的遍历
 *		b.Linkedlist(底层双链表实现的 List，查询效率低，增删效率高，线程不安全)
 *		C.vector(底层数组实现的List，线程安全)
 *  B.set接口实现类分为[长度可变，无序[存储顺序与取出不一致]，不可重复唯一}是hash值和地址（equals）的唯一
 *              hash:值是他的逻辑值，
 *              地址值：是真正的物理值
 *              set.add()方法的底层是依赖hashcod()方法与equals（）方法；
 *              a.先对hash值进行判断，如果相同比较地址值或equals（）内容；相同不添加
 *                  hash值不同就添加元素
 *            而String类要重写hashcodh(),equals(),方法  如果不重写就默认用的是Object里的方法  
 *Hashset:此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。它不保证 set 的迭代顺序；//
 *            特别是它不保证该顺序恒久不变。此类允许使用 null 元素。
 * 
 
 *
 */
public class Arraylist {
	public static void main(String[] args) {
		List list=new ArrayList();
		ArrayList list1=new ArrayList();
				  list1.ensureCapacity(50);//最小的容量
				  list1.trimToSize();//设置了列表容量的大小
		list.add("hello");//添加元素
		list.add("world");
		list.add("java");
		list.add("你好");
		list.add(4, "中国");//在指定的索引后添加元素
		System.out.println(list.get(4));//根据索引得到元素
		System.out.println(list.size());//统计元素的空间数
		System.out.println(list.contains("你好"));//判断此元素是不存在
		System.out.println(list.isEmpty());//如果此 collection 不包含元素，则返回 true
	System.out.println(list.hashCode());// 返回此 collection 的哈希码值
		System.out.println(list.indexOf("你好"));//根据元素之找出所对应的索引
		System.out.println(list.set(1, "世界"));//根据索引对元素之进行修改
		System.out.println(list.lastIndexOf("中国"));//根据最后的元素查找他所对应的索引
		//System.out.println(list.remove(3));//根据索引删除对应的元素值
		//System.out.println(list.remove("世界"));//直接删除元素值
		System.out.println("****************************");
		for(int x=0;x<list.size();x++){//list.size()与list.get()结合使用//
			//是list集合遍历特有的方法
			//不建议用System.out.println(list.get(x));
			String str=(String)list.get(x);//将Arraylist类型强制转换成String
			System.out.println(str);
		}
		System.out.println("&&&迭代器迭代元素，迭代器修改元素&添加的元素在迭代元素的后面&&");
		ListIterator aj=list.listIterator();//ConcurrentModificationException异常：当方法
		while(aj.hasNext()){//检测到对象并发修改时会抛出磁异常
			String r=(String)aj.next();//原因迭代器是依赖集合存在的，在判断成功后，集合添加的元素
			if("你好".equals(r)){//迭代器不知道，所以就抛出了并发修改异常；
				aj.add("飞吧");//其实迭代器遍历集合是，集合不能修改元素的；
			
			}//迭代器迭代元素，迭代器修改元素:Iterator没有添加功能所以用他的子接口ListIterator添加
		}
		System.out.println(list+"/n");//修改过的结果
		System.out.println("----------集合遍历元素，集合修改元素（普通的For）--------------");
		for(int i=0;i<list.size();i++){
			String h=(String)list.get(i);
			if("世界".equals(h)){
				list.add("地球");
				System.out.println(list);
			}
			
		}
		
		System.out.println("***********************8888");
    	 Person p1=new Person(1,"张三",23);
    	 Person p2=new Person(2,"李四",24);
    	 Person p3=new Person(3,"王五",25);
    	 Person p4=new Person(4,"赵六",24);
    	 Person p5=new Person(5,"孙七",34);
    	 Person p6=new Person(6,"钱二",32);
    	 Person p7=new Person(7,"石一",32); 
    	 Person p8=new Person(8,"牛八",34);
    	 List lis=new ArrayList();
    	 lis.add(p1);
    	 lis.add(p2);
    	 lis.add(p3);
    	 lis.add(p4);
    	 lis.add(p4);
    	 List<Person> li=new ArrayList<Person>();
    	 lis.add(p5);
    	 lis.add(p6);
    	 lis.add(p7);
    	 li.addAll(lis);
    	 Iterator <Person>it=lis.iterator();// 链表迭代器遍历返回的是子类的接口对象
    	 System.out.println("*************Iterator迭代器遍历***************");
    	 while(it.hasNext()){// NoSuchElementException 不要多次使用it.next()方法

    	//Person str=(Person)it.next();
    		Person str=it.next();
    	 System.out.println(str);
    	 }
    	 System.out.println("*************list特有的 链表迭代器遍历listIterator******************");
    	 ListIterator<Person> ae=lis.listIterator();//list特有的 链表迭代器遍历listIterator
    	 //继承Iterator
    	 while(ae.hasNext()){
    		 Person person=ae.next();
    		 System.out.println(person);
    	 }
    	 System.out.println("&&&&&&&&&&&用ListIterator迭代器的逆循环&&&&&&&&&&&&&&");
    	 while(ae.hasPrevious()){//判断逆向遍历列表，列表迭代器有多个元素，则返回 true。
    		 Person po=ae.previous();//返回列表中的前一个元素,
    		 System.out.println(po);
    	 }//ListIterator迭代器的逆循环必须先正顺序循环，才可以逆循环
    	 System.out.println("------for循环+迭代方法----------");
    	 for(Iterator<Person>a=lis.iterator();a.hasNext();){
    		 Person  per=a.next();//for循环+迭代方法
    		 System.out.println(per);
    	 }
    	 System.out.println("----------for循环---------------");
    	 for(int x=0;x<lis.size();x++){
    		 
    		 System.out.println(lis.get(x));
    	 }
    	System.out.println("^^^^for each循环^^^^^^^");
    	 for(Person er:li){//再创建对象时要 List<Person> li=new ArrayList<Person>();
    		 System.out.println(er);//要定位泛型才可以
    		 
    	 }
    	 
    	
}	

list数据的嵌套

           List<ArrayList<Person> > biglist= new ArrayList<ArrayList<Person>>();//1.先建个大的集合
                List<Person>per=new ArrayList<Person>();// 2.在分别建小的集合
                Person p1=new Person(1,"诸葛亮",29);
                Person p2=new Person(2,"曹操",45);
                Person p3=new Person(3,"鲁肃",34);
                Person p4=new Person(4,"周瑜",26);
                Person p5=new Person(5,"贾图",23);
                Person p6=new Person(6,"庞统",26);
                per.add(p1);
                per.add(p2);
                per.add(p3);
                per.add(p4);
                per.add(p5);
                per.add(p6);
                biglist.add((ArrayList<Person>) per);
                List<Person>per1=new ArrayList<Person>();
                Person p7=new Person(1,"孙悟空",100);
                Person p8=new Person(2,"猪八戒",120);
                Person p9=new Person(3,"沙僧",90);
                Person p01=new Person(4,"唐僧",59);
                Person p02=new Person(5,"白龙马",32);
                per1.add(p7);
                per1.add(p8);
                per1.add(p9);
                per1.add(p01);
                per1.add(p02);
                biglist.add((ArrayList<Person>) per1);
                List<Person>per2=new ArrayList<Person>();
                Person p03=new Person(1,"林冲",34);
                Person p04=new Person(2,"武松",32);
                Person p06=new Person(3,"华荣",34);
                Person p05=new Person(4,"徐宁",24);
                Person p07=new Person(5,"小七",35);
                Person p08=new Person(5,"关胜",45);
                per2.add(p03);
                per2.add(p04);
                per2.add(p05);
                per2.add(p06);
                per2.add(p07);
                per2.add(p08);
                biglist.add((ArrayList<Person>) per2);
                for(ArrayList<Person>srt:biglist){//将大的集合传递给他的下个的集合
                        for(Person st:srt){//将下个的集合传值个person类型的对象
                                System.out.println(st.getId()+st.getName()+st.getAge());
                        }
                }
        }

Iterator 与 ListIterator

实例1

/**
 * Iterator接口中的next()方法，返回迭代的下一个元素
 *   E next()
 *   返回值：迭代的下一个元素
 * **/

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

public class IteratorDemoIterator与for结合遍历List {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();	// 创建列表
        for (int i = 0; i < 10; i++) {					// 向列表中增加10个元素
            list.add(i);
        }
        System.out.println("列表中的全部元素：");
        for(Iterator<Integer> it = list.iterator();it.hasNext();) {
            System.out.print(it.next()+" ");
        }
    }
}

实例2

/**
 * ListIterator实现逆序遍历列表中的元素
 * ListIterator中的hasPrevious()方法，如果以逆向遍历列表，列表迭代器有多个元素则返回true
 *      如果previous返回一个元素而不是抛出异常，则返回true
 *       boolean hasPrevious()
 * 返回值：r如果以逆向遍历列表，列表迭代器有多个元素则返回true
 * 
 * **/

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class ListIteratorDemo逆序遍历ArrayList {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();// 创建列表
        for (int i = 0; i < 10; i++) {// 向列表中增加10个元素
            list.add(i);
        }
        System.out.println("列表中的全部元素：" + list);
        System.out.println("逆序输出列表中的元素：");
        ListIterator<Integer> li = list.listIterator();// 获得ListIterator对象
        for (li = list.listIterator(); li.hasNext();) {// 将游标定位到列表结尾
            li.next();
        }
        for (; li.hasPrevious();) {// 逆序输出列表中的元素
            System.out.print(li.previous() + " ");
        }
    }
}

/**集合也模仿数组的这种做法：在创建对象是给出明确的元素类型，这样就不会报错；
 * 而这种类型我们称之为泛型
 * 泛型是把类型明确工作推迟到，类型创建或方法调用是才去明确的特出的类型；参数化类型，把类型当参数
 一样传递有Iterator接口就用泛型
 * 格式：<数据类型>泛型里只能存放引用类型，可以定多
 * 好处：1将运行的问题提前到了编译期间；
 *      2.避免了强制性转换；
 *		3，优化了程序设计，解决了黄色警告带 ；
 *运用场合：一般 类，接口，抽象类，后有<E>就用泛型，一般使用于集合中
 *早期使用Object类型代替了各种自定义类型，向上转型是没有问题的，向下转型就出现了问题不安全；
 *所以JDK.5就出现了泛型
 *1定义泛型类-----public class Test<T>{}我的泛型在类上你传什么类型我就是什么类型
 *2.定义泛型方法--------------public<H>viod ads(H h)我的泛型在方法上你传什么类型我就是什么类型
*3.定义泛型接口：public interface Inter<T>{把泛型定义在接口上就叫泛型接口
*public abstract void asd(T t){}
*}接口的实现要用抽象类实现分为两种情况；
*1,当我实现是已经知道是什么类型；public class  Asc implement Inter<string>{}
*2,不知道是什么类型；public class  Asc <T>implement Inter<T>{}一般使用这个
*泛型的高级至通配符：
*1.<?>在不知道类型的情况下，那就是任意类型，那就是object类型的java类
*          A. 泛型如果明确些，前后必须一致；
*           LinkedList<String> li=new LinkedList<String>()
*           B.<?>代表可以任意写类型//前面不写，new的时候可以任意添加写
*           LinkedList<?> li=new LinkedList<penson>()
*           LinkedList<?> li=new LinkedList<man>()
*           LinkedList<?> li=new LinkedList<woman>()
*2.<？extends E>
*那就是向下限定，E及其子类
*        A.LinkedList<? extends Animal> li=new LinkedList<Animal>()
*        LinkedList<? extends Animal> li=new LinkedList<Dog>()//向下限定，父类----->子类
*        LinkedList<? extends Animal> li=new LinkedList<cat>()
*        LinkedList<? extends Animal> li=new LinkedList<brid>()
*3.<？super E>
*那就是向上限定，E及其父类
* A.LinkedList<? super Animal> li=new LinkedList<object>()向上限定，子类-------->父类
* LinkedList<? super Animal> li=new LinkedList<Animal>()
* 父类为泛型。
* A属性
* B方法
* 子类声明是指定类型
* 属性与方法为明确类型
* 子类为泛型了，类型在使用是确定
* 子类为泛型了，父类不确定类型，泛型的擦除用Object替换
* 要么子类与父类同时擦出，要么子类大于父类的类型
* 子类不可单独擦除，父类为泛型，
* 属性
* 父类随，父类而定
* 子类随，子类而定；
* 方法的重写
* 随父类而定；
* 
*/