24H免费课程咨询  TEL:13401595960   QQ:1870218756  微信:13401595960(李老师)

东方博宜

网站首页 > 软件开发资讯 > Java开发

Java集合知识点小结:数组、ArrayList等

2017-06-28 18:07:46 东方博宜 阅读

1:Collection




package cn.itcast_01;

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

/*
 * 集合的由来:
 *   我们学习的是面向对象语言,而面向对象语言对事物的描述是通过对象体现的,为了方便对多个对象进行操作,我们就必须把这多个对象进行存储。
 *   而要想存储多个对象,就不能是一个基本的变量,而应该是一个容器类型的变量,在我们目前所学过的知识里面,有哪些是容器类型的呢?
 *   数组和StringBuffer。但是呢?StringBuffer的结果是一个字符串,不一定满足我们的要求,所以我们只能选择数组,这就是对象数组。
 *   而对象数组又不能适应变化的需求,因为数组的长度是固定的,这个时候,为了适应变化的需求,Java就提供了集合类供我们使用。
 *
 * 数组和集合的区别?
 *   A:长度区别
 *    数组的长度固定
 *    集合长度可变
 *   B:内容不同
 *    数组存储的是同一种类型的元素
 *    而集合可以存储不同类型的元素
 *   C:元素的数据类型问题 
 *    数组可以存储基本数据类型,也可以存储引用数据类型
 *    集合只能存储引用类型
 *
 * 刚说过集合是存储多个元的,但是呢,存储多个元素我们也是有不同需求的:比如说,我要这多个元素中不能有相同的元素,
 * 再比如说,我要这多个元素按照某种规则排序一下。针对不同的需求,Java就提供了不同的集合类,这样呢,Java就提供了很多个集合类。
 * 这多个集合类的数据结构不同,结构不同不重要的,重要的是你要能够存储东西,并且还要能够使用这些东西,比如说判断,获取等。
 * 既然这样,那么,这多个集合类是有共性的内容的,我们把这些集合类的共性内容不断的向上提取,最终就能形成集合的继承体系结构。
 *
 * 数据结构:数据的存储方式。
 *
 * Collection:是集合的顶层接口,它的子体系有重复的,有唯一的,有有序的,有无序的。(后面会慢慢的讲解)
 *
 * Collection的功能概述:
 * 1:添加功能
 *   boolean add(Object obj):添加一个元素
 *   boolean addAll(Collection c):添加一个集合的元素
 * 2:删除功能
 *   void clear():移除所有元素
 *   boolean remove(Object o):移除一个元素
 *   boolean removeAll(Collection c):移除一个集合的元素(是一个还是所有)
 * 3:判断功能
 *   boolean contains(Object o):判断集合中是否包含指定的元素
 *   boolean containsAll(Collection c):判断集合中是否包含指定的集合元素(是一个还是所有)
 *   boolean isEmpty():判断集合是否为空
 * 4:获取功能
 *   Iterator<E> iterator()(重点)
 * 5:长度功能
 *   int size():元素的个数
 *   面试题:数组有没有length()方法呢?字符串有没有length()方法呢?集合有没有length()方法呢?
 * 6:交集功能
 *   boolean retainAll(Collection c):两个集合都有的元素?思考元素去哪了,返回的boolean又是什么意思呢?
 * 7:把集合转换为数组
 *   Object[] toArray()
 */
public class CollectionDemo {
 public static void main(String[] args) {
  // 测试不带All的方法

  // 创建集合对象
  // Collection c = new Collection(); //错误,因为接口不能实例化
  Collection c = new ArrayList();

  // boolean add(Object obj):添加一个元素
  // System.out.println("add:"+c.add("hello"));
  c.add("hello");
  c.add("world");
  c.add("java");

  // void clear():移除所有元素
  // c.clear();

  // boolean remove(Object o):移除一个元素
  // System.out.println("remove:" + c.remove("hello"));
  // System.out.println("remove:" + c.remove("javaee"));

  // boolean contains(Object o):判断集合中是否包含指定的元素
  // System.out.println("contains:"+c.contains("hello"));
  // System.out.println("contains:"+c.contains("android"));

  // boolean isEmpty():判断集合是否为空
  // System.out.println("isEmpty:"+c.isEmpty());

  //int size():元素的个数
  System.out.println("size:"+c.size());
  
  System.out.println("c:" + c);
 }
}



package cn.itcast_01;

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

/*
 * boolean addAll(Collection c):添加一个集合的元素
 * boolean removeAll(Collection c):移除一个集合的元素(是一个还是所有)
 * boolean containsAll(Collection c):判断集合中是否包含指定的集合元素(是一个还是所有)
 * boolean retainAll(Collection c):两个集合都有的元素?思考元素去哪了,返回的boolean又是什么意思呢?
 */
public class CollectionDemo2 {
 public static void main(String[] args) {
  // 创建集合1
  Collection c1 = new ArrayList();
  c1.add("abc1");
  c1.add("abc2");
  c1.add("abc3");
  c1.add("abc4");

  // 创建集合2
  Collection c2 = new ArrayList();
//  c2.add("abc1");
//  c2.add("abc2");
//  c2.add("abc3");
//  c2.add("abc4");
  c2.add("abc5");
  c2.add("abc6");
  c2.add("abc7");

  // boolean addAll(Collection c):添加一个集合的元素
  // System.out.println("addAll:" + c1.addAll(c2));
  
  //boolean removeAll(Collection c):移除一个集合的元素(是一个还是所有)
  //只要有一个元素被移除了,就返回true。
  //System.out.println("removeAll:"+c1.removeAll(c2));

  //boolean containsAll(Collection c):判断集合中是否包含指定的集合元素(是一个还是所有)
  //只有包含所有的元素,才叫包含
  // System.out.println("containsAll:"+c1.containsAll(c2));
  
  //boolean retainAll(Collection c):两个集合都有的元素?思考元素去哪了,返回的boolean又是什么意思呢?
  //假设有两个集合A,B。
  //A对B做交集,最终的结果保存在A中,B不变。
  //返回值表示的是A是否发生过改变。
  System.out.println("retainAll:"+c1.retainAll(c2));
  
  System.out.println("c1:" + c1);
  System.out.println("c2:" + c2);
 }
}



package cn.itcast_01;

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

/*
 * 集合的遍历。其实就是依次获取集合中的每一个元素。
 *
 * Object[] toArray():把集合转成数组,可以实现集合的遍历
 */
public class CollectionDemo3 {
 public static void main(String[] args) {
  // 创建集合对象
  Collection c = new ArrayList();

  // 添加元素
  c.add("hello"); // Object obj = "hello"; 向上转型
  c.add("world");
  c.add("java");

  // 遍历
  // Object[] toArray():把集合转成数组,可以实现集合的遍历
  Object[] objs = c.toArray();
  for (int x = 0; x < objs.length; x++) {
   // System.out.println(objs[x]);
   // 我知道元素是字符串,我在获取到元素的的同时,还想知道元素的长度。
   // System.out.println(objs[x] + "---" + objs[x].length());
   // 上面的实现不了,原因是Object中没有length()方法
   // 我们要想使用字符串的方法,就必须把元素还原成字符串
   // 向下转型
   String s = (String) objs[x];
   System.out.println(s + "---" + s.length());
  }
 }
}



package cn.itcast_02;

public class Student {
 // 成员变量
 private String name;
 private int age;

 // 构造方法
 public Student() {
  super();
 }

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

 // 成员方法
 // getXxx()/setXxx()
 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;
 }
}



package cn.itcast_02;

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

/*
 * 练习:用集合存储5个学生对象,并把学生对象进行遍历。
 *
 * 分析:
 * A:创建学生类
 * B:创建集合对象
 * C:创建学生对象
 * D:把学生添加到集合
 * E:把集合转成数组
 * F:遍历数组
 */
public class StudentDemo {
 public static void main(String[] args) {
  // 创建集合对象
  Collection c = new ArrayList();

  // 创建学生对象
  Student s1 = new Student("林青霞", 27);
  Student s2 = new Student("风清扬", 30);
  Student s3 = new Student("令狐冲", 33);
  Student s4 = new Student("武鑫", 25);
  Student s5 = new Student("刘晓曲", 22);

  // 把学生添加到集合
  c.add(s1);
  c.add(s2);
  c.add(s3);
  c.add(s4);
  c.add(s5);

  // 把集合转成数组
  Object[] objs = c.toArray();
  // 遍历数组
  for (int x = 0; x < objs.length; x++) {
   // System.out.println(objs[x]);

   Student s = (Student) objs[x];
   System.out.println(s.getName() + "---" + s.getAge());
  }
 }
}



package cn.itcast_03;

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

/*
 * Iterator iterator():迭代器,集合的专用遍历方式
 *   Object next():获取元素,并移动到下一个位置。
 *    NoSuchElementException:没有这样的元素,因为你已经找到最后了。
 *   boolean hasNext():如果仍有元素可以迭代,则返回 true。(
 */
public class IteratorDemo {
 public static void main(String[] args) {
  // 创建集合对象
  Collection c = new ArrayList();

  // 创建并添加元素
  // String s = "hello";
  // c.add(s);
  c.add("hello");
  c.add("world");
  c.add("java");

  // Iterator iterator():迭代器,集合的专用遍历方式
  Iterator it = c.iterator(); // 实际返回的肯定是子类对象,这里是多态

  // Object obj = it.next();
  // System.out.println(obj);
  // System.out.println(it.next());
  // System.out.println(it.next());
  // System.out.println(it.next());
  // System.out.println(it.next());
  // 最后一个不应该写,所以,我们应该在每次获取前,如果有一个判断就好了
  // 判断是否有下一个元素,有就获取,没有就不搭理它

  // if (it.hasNext()) {
  // System.out.println(it.next());
  // }
  // if (it.hasNext()) {
  // System.out.println(it.next());
  // }
  // if (it.hasNext()) {
  // System.out.println(it.next());
  // }
  // if (it.hasNext()) {
  // System.out.println(it.next());
  // }
  // if (it.hasNext()) {
  // System.out.println(it.next());
  // }

  // 最终版代码
  while (it.hasNext()) {
   // System.out.println(it.next());
   String s = (String) it.next();
   System.out.println(s);
  }
 }
}



package cn.itcast_03;

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

/*
 * 练习:用集合存储5个学生对象,并把学生对象进行遍历。用迭代器遍历。
 *
 * 注意:
 *   A:自己的类名不要和我们学习的要使用的API中的类名相同。
 *   B:复制代码的时候,很容易把那个类所在的包也导入过来,容易出现不能理解的问题。
 */
public class IteratorTest {
 public static void main(String[] args) {
  // 创建集合对象
  Collection c = new ArrayList();

  // 创建学生对象
  Student s1 = new Student("林青霞", 27);
  Student s2 = new Student("风清扬", 30);
  Student s3 = new Student("令狐冲", 33);
  Student s4 = new Student("武鑫", 25);
  Student s5 = new Student("刘晓曲", 22);

  // 把学生添加到集合中
  c.add(s1);
  c.add(s2);
  c.add(s3);
  c.add(s4);
  c.add(s5);

  // 遍历
  Iterator it = c.iterator();
  while (it.hasNext()) {
   // System.out.println(it.next());
   Student s = (Student) it.next();
   System.out.println(s.getName() + "---" + s.getAge());
  }
 }
}



package cn.itcast_03;

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

/*
 * 问题1:能用while循环写这个程序,我能不能用for循环呢?
 * 问题2:不要多次使用it.next()方法,因为每次使用都是访问一个对象。
 */
public class IteratorTest2 {
 public static void main(String[] args) {
  // 创建集合对象
  Collection c = new ArrayList();

  // 创建学生对象
  Student s1 = new Student("林青霞", 27);
  Student s2 = new Student("风清扬", 30);
  Student s3 = new Student("令狐冲", 33);
  Student s4 = new Student("武鑫", 25);
  Student s5 = new Student("刘晓曲", 22);

  // 把学生添加到集合中
  c.add(s1);
  c.add(s2);
  c.add(s3);
  c.add(s4);
  c.add(s5);

  // 遍历
  Iterator it = c.iterator();
  while (it.hasNext()) {
   Student s = (Student) it.next();
   System.out.println(s.getName() + "---" + s.getAge());

   // NoSuchElementException 不要多次使用it.next()方法
   // System.out.println(((Student) it.next()).getName() + "---"
   // + ((Student) it.next()).getAge());

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

  // for循环改写
  // for(Iterator it = c.iterator();it.hasNext();){
  // Student s = (Student) it.next();
  // System.out.println(s.getName() + "---" + s.getAge());
  // }
 }
}



package cn.itcast_03;

public class Student {
 // 成员变量
 private String name;
 private int age;

 // 构造方法
 public Student() {
  super();
 }

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

 // 成员方法
 // getXxx()/setXxx()
 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 + "]";
 }
 
}



 

package cn.itcast_04;

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

/*
 * 需求:存储字符串并遍历。
 *
 * 分析:
 *   A:创建集合对象
 *   B:创建字符串对象
 *   C:把字符串对象添加到集合中
 *   D:遍历集合
 */
public class CollectionTest {
 public static void main(String[] args) {
  // 创建集合对象
  Collection c = new ArrayList();

  // 创建字符串对象
  // 把字符串对象添加到集合中
  c.add("林青霞");
  c.add("风清扬");
  c.add("刘意");
  c.add("武鑫");
  c.add("刘晓曲");

  // 遍历集合
  // 通过集合对象获取迭代器对象
  Iterator it = c.iterator();
  // 通过迭代器对象的hasNext()方法判断有没有元素
  while (it.hasNext()) {
   // 通过迭代器对象的next()方法获取元素
   String s = (String) it.next();
   System.out.println(s);
  }
 }
}

                                     图一 集合的继承体系图解

image.png



package cn.itcast_04;

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

/*
 * 需求:存储自定义对象并遍历Student(name,age)
 *
 * 分析:
 *   A:创建学生类
 *   B:创建集合对象
 *   C:创建学生对象
 *   D:把学生对象添加到集合对象中
 *   E:遍历集合
 */
public class CollectionTest2 {
 public static void main(String[] args) {
  // 创建集合对象
  Collection c = new ArrayList();

  // 创建学生对象
  Student s1 = new Student("貂蝉", 25);
  Student s2 = new Student("小乔", 16);
  Student s3 = new Student("黄月英", 20);
  Student s4 = new Student();
  s4.setName("大乔");
  s4.setAge(26);

  // 把学生对象添加到集合对象中
  c.add(s1);
  c.add(s2);
  c.add(s3);
  c.add(s4);
  c.add(new Student("孙尚香", 18)); // 匿名对象

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



package cn.itcast_04;

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

 public Student() {
  super();
 }

 public Student(String name, int age) {
  super();
  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;
 }

}

                            图二:迭代器使用图解和原理解析

 

image.png

 



2:迭代器源码

public interface Inteator {
 boolean hasNext();
 Object next();
}

public interface Iterable {
    Iterator iterator();
}

public interface Collection extends Iterable {
 Iterator iterator();
}

public interface List extends Collection {
 Iterator iterator();
}

public class ArrayList implements List {
 public Iterator iterator() {
        return new Itr();
    }
   
    private class Itr implements Iterator {
     public boolean hasNext() {}
  public Object next(){}
    }
}


Collection c = new ArrayList();
c.add("hello");
c.add("world");
c.add("java");
Iterator it = c.iterator();  //new Itr();
while(it.hasNext()) {
 String s = (String)it.next();
 System.out.println(s);
}



3:List类

package cn.itcast_01;

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

/*
 * 需求:List集合存储字符串并遍历。
 */
public class ListDemo {
 public static void main(String[] args) {
  // 创建集合对象
  List list = new ArrayList();

  // 创建字符串并添加字符串
  list.add("hello");
  list.add("world");
  list.add("java");

  // 遍历集合
  Iterator it = list.iterator();
  while (it.hasNext()) {
   String s = (String) it.next();
   System.out.println(s);
  }
 }
}



package cn.itcast_01;

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

/*
 * List集合的特点:
 *   有序(存储和取出的元素一致),可重复的。
 */
public class ListDemo2 {
 public static void main(String[] args) {
  // 创建集合对象
  List list = new ArrayList();

  // 存储元素
  list.add("hello");
  list.add("world");
  list.add("java");
  list.add("javaee");
  list.add("android");
  list.add("javaee");
  list.add("android");

  // 遍历集合
  Iterator it = list.iterator();
  while (it.hasNext()) {
   String s = (String) it.next();
   System.out.println(s);
  }
 }
}



package cn.itcast_02;

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

/*
 * 存储自定义对象并遍历
 */
public class ListDemo {
 public static void main(String[] args) {
  // 创建集合对象
  List list = new ArrayList();

  // 创建学生对象
  Student s1 = new Student("白骨精", 30);
  Student s2 = new Student("蜘蛛精", 40);
  Student s3 = new Student("观音姐姐", 22);

  // 把学生对象添加到集合对象中
  list.add(s1);
  list.add(s2);
  list.add(s3);

  // 遍历
  Iterator it = list.iterator();
  while (it.hasNext()) {
   Student s = (Student) it.next();
   System.out.println(s.getName() + "---" + s.getAge());
  }
 }
}



package cn.itcast_02;

public class Student {
 // 成员变量
 private String name;
 private int age;

 // 构造方法
 public Student() {
  super();
 }

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

 // 成员方法
 // getXxx()/setXxx()
 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;
 }
}



package cn.itcast_03;

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

/*
 * List集合的特有功能:
 * A:添加功能
 *   void add(int index,Object element):在指定位置添加元素
 * B:获取功能
 *   Object get(int index):获取指定位置的元素
 * C:列表迭代器
 *   ListIterator listIterator():List集合特有的迭代器
 * D:删除功能
 *   Object remove(int index):根据索引删除元素,返回被删除的元素
 * E:修改功能
 *   Object set(int index,Object element):根据索引修改元素,返回被修饰的元素
 */
public class ListDemo {
 public static void main(String[] args) {
  // 创建集合对象
  List list = new ArrayList();

  // 添加元素
  list.add("hello");
  list.add("world");
  list.add("java");

  // void add(int index,Object element):在指定位置添加元素
  // list.add(1, "android");//没有问题
  // IndexOutOfBoundsException
  // list.add(11, "javaee");//有问题
  // list.add(3, "javaee"); //没有问题
  // list.add(4, "javaee"); //有问题

  // Object get(int index):获取指定位置的元素
  // System.out.println("get:" + list.get(1));
  // IndexOutOfBoundsException
  // System.out.println("get:" + list.get(11));

  // Object remove(int index):根据索引删除元素,返回被删除的元素
  // System.out.println("remove:" + list.remove(1));
  // IndexOutOfBoundsException
  // System.out.println("remove:" + list.remove(11));

  // Object set(int index,Object element):根据索引修改元素,返回被修饰的元素
  System.out.println("set:" + list.set(1, "javaee"));

  System.out.println("list:" + list);
 }
}



package cn.itcast_03;

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

/*
 * List集合的特有遍历功能:
 *   size()和get()方法结合使用
 */
public class ListDemo2 {
 public static void main(String[] args) {
  // 创建集合对象
  List list = new ArrayList();

  // 添加元素
  list.add("hello");
  list.add("world");
  list.add("java");

  // Object get(int index):获取指定位置的元素
  // System.out.println(list.get(0));
  // System.out.println(list.get(1));
  // System.out.println(list.get(2));
  // IndexOutOfBoundsException
  // System.out.println(list.get(3));

  // 用循环改进
  // for (int x = 0; x < 3; x++) {
  // System.out.println(list.get(x));
  // }
  // 如果元素过多,数起来就比较麻烦,所以我们使用集合的一个长度功能:size()
  // 最终的遍历方式就是:size()和get()
  for (int x = 0; x < list.size(); x++) {
   // System.out.println(list.get(x));

   String s = (String) list.get(x);
   System.out.println(s);
  }
 }
}



package cn.itcast_03;

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

/*
 * 存储自定义对象并遍历,用普通for循环。(size()和get()结合)
 */
public class ListDemo3 {
 public static void main(String[] args) {
  // 创建集合对象
  List list = new ArrayList();

  // 创建学生对象
  Student s1 = new Student("林黛玉", 18);
  Student s2 = new Student("刘姥姥", 88);
  Student s3 = new Student("王熙凤", 38);

  // 把学生添加到集合中
  list.add(s1);
  list.add(s2);
  list.add(s3);

  // 遍历
  // 迭代器遍历
  Iterator it = list.iterator();
  while (it.hasNext()) {
   Student s = (Student) it.next();
   System.out.println(s.getName() + "---" + s.getAge());
  }
  System.out.println("--------");

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



package cn.itcast_03;

public class Student {
 // 成员变量
 private String name;
 private int age;

 // 构造方法
 public Student() {
  super();
 }

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

 // 成员方法
 // getXxx()/setXxx()
 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;
 }
}



package cn.itcast_04;

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

/*
 * 列表迭代器:
 *   ListIterator listIterator():List集合特有的迭代器
 *   该迭代器继承了Iterator迭代器,所以,就可以直接使用hasNext()和next()方法。
 *
 * 特有功能:
 *   Object previous():获取上一个元素
 *   boolean hasPrevious():判断是否有元素
 *
 *   注意:ListIterator可以实现逆向遍历,但是必须先正向遍历,才能逆向遍历,所以一般无意义,不使用。
 */
public class ListIteratorDemo {
 public static void main(String[] args) {
  // 创建List集合对象
  List list = new ArrayList();
  list.add("hello");
  list.add("world");
  list.add("java");

  // ListIterator listIterator()
  ListIterator lit = list.listIterator(); // 子类对象
  // while (lit.hasNext()) {
  // String s = (String) lit.next();
  // System.out.println(s);
  // }
  // System.out.println("-----------------");
  
  // System.out.println(lit.previous());
  // System.out.println(lit.previous());
  // System.out.println(lit.previous());
  // NoSuchElementException
  // System.out.println(lit.previous());

  while (lit.hasPrevious()) {
   String s = (String) lit.previous();
   System.out.println(s);
  }
  System.out.println("-----------------");

  // 迭代器
  Iterator it = list.iterator();
  while (it.hasNext()) {
   String s = (String) it.next();
   System.out.println(s);
  }
  System.out.println("-----------------");

 }
}



package cn.itcast_04;

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

/*
 * 问题?
 *   我有一个集合,如下,请问,我想判断里面有没有"world"这个元素,如果有,我就添加一个"javaee"元素,请写代码实现。
 *
 * ConcurrentModificationException:当方法检测到对象的并发修改,但不允许这种修改时,抛出此异常。
 * 产生的原因:
 *   迭代器是依赖于集合而存在的,在判断成功后,集合的中新添加了元素,而迭代器却不知道,所以就报错了,这个错叫并发修改异常。
 *   其实这个问题描述的是:迭代器遍历元素的时候,通过集合是不能修改元素的。
 * 如何解决呢?
 *   A:迭代器迭代元素,迭代器修改元素
 *    元素是跟在刚才迭代的元素后面的。
 *   B:集合遍历元素,集合修改元素(普通for)
 *    元素在最后添加的。
 */
public class ListIteratorDemo2 {
 public static void main(String[] args) {
  // 创建List集合对象
  List list = new ArrayList();
  // 添加元素
  list.add("hello");
  list.add("world");
  list.add("java");

  // 迭代器遍历
  // Iterator it = list.iterator();
  // while (it.hasNext()) {
  // String s = (String) it.next();
  // if ("world".equals(s)) {
  // list.add("javaee");
  // }
  // }

  // 方式1:迭代器迭代元素,迭代器修改元素
  // 而Iterator迭代器却没有添加功能,所以我们使用其子接口ListIterator
  // ListIterator lit = list.listIterator();
  // while (lit.hasNext()) {
  // String s = (String) lit.next();
  // if ("world".equals(s)) {
  // lit.add("javaee");
  // }
  // }

  // 方式2:集合遍历元素,集合修改元素(普通for)
  for (int x = 0; x < list.size(); x++) {
   String s = (String) list.get(x);
   if ("world".equals(s)) {
    list.add("javaee");
   }
  }

  System.out.println("list:" + list);
 }
}



4:list子类的特点

List:(面试题List的子类特点)
 ArrayList:
  底层数据结构是数组,查询快,增删慢。
  线程不安全,效率高。
 Vector:
  底层数据结构是数组,查询快,增删慢。
  线程安全,效率低。
 LinkedList:
  底层数据结构是链表,查询慢,增删快。
  线程不安全,效率高。
  
 List有三个儿子,我们到底使用谁呢?
  看需求(情况)。
  
 要安全吗?
  要:Vector(即使要安全,也不用这个了,后面有替代的)
  不要:ArrayList或者LinkedList
   查询多:ArrayList
   增删多:LinkedList
   
 如果你什么都不懂,就用ArrayList。



5 ObjectArray类

 package cn.itcast_01;

/*
 * 我有5个学生,请把这个5个学生的信息存储到数组中,并遍历数组,获取得到每一个学生信息。
 *   学生:Student
 *   成员变量:name,age
 *   构造方法:无参,带参
 *   成员方法:getXxx()/setXxx()
 *   存储学生的数组?自己想想应该是什么样子的?
 * 分析:
 *   A:创建学生类。
 *   B:创建学生数组(对象数组)。
 *   C:创建5个学生对象,并赋值。
 *   D:把C步骤的元素,放到数组中。
 *   E:遍历学生数组。
 */
public class ObjectArrayDemo {
 public static void main(String[] args) {
  // 创建学生数组(对象数组)。
  Student[] students = new Student[5];
  // for (int x = 0; x < students.length; x++) {
  // System.out.println(students[x]);
  // }
  // System.out.println("---------------------");

  // 创建5个学生对象,并赋值。
  Student s1 = new Student("林青霞", 27);
  Student s2 = new Student("风清扬", 30);
  Student s3 = new Student("刘意", 30);
  Student s4 = new Student("赵雅芝", 60);
  Student s5 = new Student("王力宏", 35);

  // 把C步骤的元素,放到数组中。
  students[0] = s1;
  students[1] = s2;
  students[2] = s3;
  students[3] = s4;
  students[4] = s5;

  // 看到很相似,就想循环改
  // for (int x = 0; x < students.length; x++) {
  // students[x] = s + "" + (x + 1);
  // }
  // 这个是有问题的

  // 遍历
  for (int x = 0; x < students.length; x++) {
   //System.out.println(students[x]);
   
   Student s = students[x];
   System.out.println(s.getName()+"---"+s.getAge());
  }
 }
}




package cn.itcast_01;

public class Student {
 // 成员变量
 private String name;
 private int age;

 // 构造方法
 public Student() {
  super();
 }

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

 // 成员方法
 // getXxx()/setXxx()
 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 + "]";
 }
}




                           图三 对象数组的内存图解

image.png

                     图四  数据结构之数组和链表

image.png

                     图五  数据结构之栈和队列

 image.png




6:Generic

package cn.itcast_01;

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

/*
 * ArrayList存储字符串并遍历
 *
 * 我们按照正常的写法来写这个程序, 结果确出错了。
 * 为什么呢?
 *   因为我们开始存储的时候,存储了String和Integer两种类型的数据。
 *   而在遍历的时候,我们把它们都当作String类型处理的,做了转换,所以就报错了。
 * 但是呢,它在编译期间却没有告诉我们。
 * 所以,我就觉得这个设计的不好。
 * 回想一下,我们的数组
 *   String[] strArray = new String[3];
 *   strArray[0] = "hello";
 *   strArray[1] = "world";
 *   strArray[2] = 10;
 * 集合也模仿着数组的这种做法,在创建对象的时候明确元素的数据类型。这样就不会在有问题了。
 * 而这种技术被称为:泛型。
 *
 * 泛型:是一种把类型明确的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。参数化类型,把类型当作参数一样的传递。
 * 格式:
 *   <数据类型>
 *   此处的数据类型只能是引用类型。
 * 好处:
 *   A:把运行时期的问题提前到了编译期间
 *   B:避免了强制类型转换
 *   C:优化了程序设计,解决了黄色警告线
 */
public class GenericDemo {
 public static void main(String[] args) {
  // 创建
  ArrayList<String> array = new ArrayList<String>();

  // 添加元素
  array.add("hello");
  array.add("world");
  array.add("java");
  // array.add(new Integer(100));
  //array.add(10); // JDK5以后的自动装箱
  // 等价于:array.add(Integer.valueOf(10));

  // 遍历
  Iterator<String> it = array.iterator();
  while (it.hasNext()) {
   // ClassCastException
   // String s = (String) it.next();
   String s = it.next();
   System.out.println(s);
  }

  // 看下面这个代码
  // String[] strArray = new String[3];
  // strArray[0] = "hello";
  // strArray[1] = "world";
  // strArray[2] = 10;
 }
}



package cn.itcast_02;

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

/*
 * 泛型在哪些地方使用呢?
 *   看API,如果类,接口,抽象类后面跟的有<E>就说要使用泛型。一般来说就是在集合中使用。
 */
public class ArrayListDemo {
 public static void main(String[] args) {
  // 用ArrayList存储字符串元素,并遍历。用泛型改进代码
  ArrayList<String> array = new ArrayList<String>();

  array.add("hello");
  array.add("world");
  array.add("java");

  Iterator<String> it = array.iterator();
  while (it.hasNext()) {
   String s = it.next();
   System.out.println(s);
  }
  System.out.println("-----------------");

  for (int x = 0; x < array.size(); x++) {
   String s = array.get(x);
   System.out.println(s);
  }
 }
}



package cn.itcast_02;

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

/*
 * 需求:存储自定义对象并遍历。
 *
 * A:创建学生类
 * B:创建集合对象
 * C:创建元素对象
 * D:把元素添加到集合
 * E:遍历集合
 */
public class ArrayListDemo2 {
 public static void main(String[] args) {
  // 创建集合对象
  // JDK7的新特性:泛型推断。
  // ArrayList<Student> array = new ArrayList<>();
  // 但是我不建议这样使用。
  ArrayList<Student> array = new ArrayList<Student>();

  // 创建元素对象
  Student s1 = new Student("曹操", 40); // 后知后觉
  Student s2 = new Student("蒋干", 30); // 不知不觉
  Student s3 = new Student("诸葛亮", 26);// 先知先觉

  // 添加元素
  array.add(s1);
  array.add(s2);
  array.add(s3);

  // 遍历
  Iterator<Student> it = array.iterator();
  while (it.hasNext()) {
   Student s = it.next();
   System.out.println(s.getName() + "---" + s.getAge());
  }
  System.out.println("------------------");

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



package cn.itcast_02;

/**
 * 这是学生描述类
 *
 * @author 风清扬
 * @version V1.0
 */
public class Student {
 // 姓名
 private String name;
 // 年龄
 private int age;

 public Student() {
  super();
 }

 public Student(String name, int age) {
  super();
  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;
 }

}



package cn.itcast_03;

public class ObjectTool {
 private Object obj;

 public Object getObj() {
  return obj;
 }

 public void setObj(Object obj) { // Object obj = new Integer(30);
  this.obj = obj;
 }
}



package cn.itcast_03;

/*
 * 早期的时候,我们使用Object来代表任意的类型。
 * 向上转型是没有任何问题的,但是在向下转型的时候其实隐含了类型转换的问题。
 * 也就是说这样的程序其实并不是安全的。所以Java在JDK5后引入了泛型,提高程序的安全性。
 */
public class ObjectToolDemo {
 public static void main(String[] args) {
  ObjectTool ot = new ObjectTool();

  // 正常使用
  ot.setObj(new Integer(27));
  Integer i = (Integer) ot.getObj();
  System.out.println("年龄是:" + i);

  ot.setObj(new String("林青霞"));
  String s = (String) ot.getObj();
  System.out.println("姓名是:" + s);

  System.out.println("---------");
  ot.setObj(new Integer(30));
  // ClassCastException
  String ss = (String) ot.getObj();
  System.out.println("姓名是:" + ss);
 }
}



package cn.itcast_04;

/*
 * 泛型类:把泛型定义在类上
 */
public class ObjectTool<T> {
 private T obj;

 public T getObj() {
  return obj;
 }

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




package cn.itcast_04;

/*
 * 泛型类的测试
 */
public class ObjectToolDemo {
 public static void main(String[] args) {
  // ObjectTool ot = new ObjectTool();
  //
  // ot.setObj(new String("风清扬"));
  // String s = (String) ot.getObj();
  // System.out.println("姓名是:" + s);
  //
  // ot.setObj(new Integer(30));
  // Integer i = (Integer) ot.getObj();
  // System.out.println("年龄是:" + i);

  // ot.setObj(new String("林青霞"));
  // // ClassCastException
  // Integer ii = (Integer) ot.getObj();
  // System.out.println("姓名是:" + ii);

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

  ObjectTool<String> ot = new ObjectTool<String>();
  // ot.setObj(new Integer(27)); //这个时候编译期间就过不去
  ot.setObj(new String("林青霞"));
  String s = ot.getObj();
  System.out.println("姓名是:" + s);

  ObjectTool<Integer> ot2 = new ObjectTool<Integer>();
  // ot2.setObj(new String("风清扬"));//这个时候编译期间就过不去
  ot2.setObj(new Integer(27));
  Integer i = ot2.getObj();
  System.out.println("年龄是:" + i);
 }
}




package cn.itcast_05;

//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);
 }
}



package cn.itcast_05;


public class ObjectToolDemo {
 public static void main(String[] args) {
  // ObjectTool ot = new ObjectTool();
  // ot.show("hello");
  // ot.show(100);
  // ot.show(true);

  // ObjectTool<String> ot = new ObjectTool<String>();
  // ot.show("hello");
  //
  // ObjectTool<Integer> ot2 = new ObjectTool<Integer>();
  // ot2.show(100);
  //
  // ObjectTool<Boolean> ot3 = new ObjectTool<Boolean>();
  // ot3.show(true);

  // 如果还听得懂,那就说明泛型类是没有问题的
  // 但是呢,谁说了我的方法一定要和类的类型的一致呢?
  // 我要是类上没有泛型的话,方法还能不能接收任意类型的参数了呢?

  // 定义泛型方法后
  ObjectTool ot = new ObjectTool();
  ot.show("hello");
  ot.show(100);
  ot.show(true);
 }
}



package cn.itcast_06;

/*
 * 泛型接口:把泛型定义在接口上
 */
public interface Inter<T> {
 public abstract void show(T t);
}



package cn.itcast_06;

public class InterDemo {
 public static void main(String[] args) {
  // 第一种情况的测试
  // Inter<String> i = new InterImpl();
  // i.show("hello");

  // // 第二种情况的测试
  Inter<String> i = new InterImpl<String>();
  i.show("hello");

  Inter<Integer> ii = new InterImpl<Integer>();
  ii.show(100);
 }
}



package cn.itcast_06;

//实现类在实现接口的时候
//第一种情况:已经知道该是什么类型的了

//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);
 }
}



package cn.itcast_07;

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

/*
 * 泛型高级(通配符)
 * ?:任意类型,如果没有明确,那么就是Object以及任意的Java类了
 * ? extends 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<Animal>();
  // Collection<Object> c3 = new ArrayList<Dog>();
  // Collection<Object> c4 = new ArrayList<Cat>();

  // ?表示任意的类型都是可以的
  Collection<?> c5 = new ArrayList<Object>();
  Collection<?> c6 = new ArrayList<Animal>();
  Collection<?> c7 = new ArrayList<Dog>();
  Collection<?> c8 = new ArrayList<Cat>();

  // ? extends E:向下限定,E及其子类
  // Collection<? extends Animal> c9 = new ArrayList<Object>();
  Collection<? extends Animal> c10 = new ArrayList<Animal>();
  Collection<? extends Animal> c11 = new ArrayList<Dog>();
  Collection<? extends Animal> c12 = new ArrayList<Cat>();

  // ? super E:向上限定,E极其父类
  Collection<? super Animal> c13 = new ArrayList<Object>();
  Collection<? super Animal> c14 = new ArrayList<Animal>();
  // Collection<? super Animal> c15 = new ArrayList<Dog>();
  // Collection<? super Animal> c16 = new ArrayList<Cat>();
 }
}

class Animal {
}

class Dog extends Animal {
}

class Cat extends Animal {
}


Powered by 东方博宜教育咨询江苏有限公司  ©2008-2017 www.czos.cn