集合框架-ArrayList,Vector,Linkedlist

// ClassCastException 报错，注意，千万要搞清楚类型

* Vector的特有功能：
* 1：添加功能
* public void addElement(Object obj) -- 被add()替代
* 2：获取功能
* public Object elementAt(int index) -- 被 get()替代
* public Enumeration elements() -- 被Iterator iterator()替代
* boolean hasMoreElements() -- 被 hasNext()替代
* Object nextElement() -- 被 next()替代
*
* JDK升级的原因：
* A:安全
* B:效率
* C:简化书写

         // 创建集合对象
         Vector v = new Vector();
 
         // 添加功能
         v.addElement("hello");
         v.addElement("world");
         v.addElement("java");
 
         // 遍历
         for (int x = 0; x < v.size(); x++) {
             String s = (String) v.elementAt(x);
             System.out.println(s);
         }
 
         System.out.println("------------------");
 
         Enumeration en = v.elements(); // 返回的是实现类的对象
         while (en.hasMoreElements()) {
             String s = (String) en.nextElement();
             System.out.println(s);
         }

* LinkedList的特有功能：
* A:添加功能
* public void addFirst(Object e)
* public void addLast(Object e)
* B:获取功能
* public Object getFirst()
* public Obejct getLast()
* C:删除功能
* public Object removeFirst()
* public Object removeLast()

* ArrayList去除集合中字符串的重复值(字符串的内容相同)
*
* 分析：
* A:创建集合对象
* B:添加多个字符串元素(包含内容相同的)
* C:创建新集合
* D:遍历旧集合,获取得到每一个元素
* E:拿这个元素到新集合去找，看有没有
* 有：不搭理它
* 没有：就添加到新集合
* F:遍历新集合

         // 创建集合对象
         ArrayList array = new ArrayList();
 
         // 添加多个字符串元素(包含内容相同的)
         array.add("java");
         array.add("world");
         array.add("java");
         array.add("world");
 
         // 创建新集合
         ArrayList newArray = new ArrayList();
 
         // 遍历旧集合,获取得到每一个元素
         Iterator it = array.iterator();
         while (it.hasNext()) {
             String s = (String) it.next();
 
             // 拿这个元素到新集合去找，看有没有
             if (!newArray.contains(s)) {
                 newArray.add(s);
             }
         }
 
         // 遍历新集合
         for (int x = 0; x < newArray.size(); x++) {
             String s = (String) newArray.get(x);
             System.out.println(s);
         }
     }

方法二：

* 需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)
* 要求：不能创建新的集合，就在以前的集合上做。

         // 由选择排序思想引入，我们就可以通过这种思想做这个题目
         // 拿0索引的依次和后面的比较，有就把后的干掉
         // 同理，拿1索引...
         for (int x = 0; x < array.size() - 1; x++) {
             for (int y = x + 1; y < array.size(); y++) {
                 if (array.get(x).equals(array.get(y))) {
                     array.remove(y);
                     y--;
                 }
             }
         }

* 需求：去除集合中自定义对象的重复值(对象的成员变量值都相同)
*
* 我们按照和字符串一样的操作，发现出问题了。
* 而这个判断功能是集合自己提供的，所以我们如果想很清楚的知道它是如何判断的，就应该去看源码。
* contains()方法的底层依赖的是equals()方法。
* 而我们的学生类中没有equals()方法，这个时候，默认使用的是它父亲Object的equals()方法
* Object()的equals()默认比较的是地址值，所以，它们进去了。因为new的东西，地址值都不同。
* 按照我们自己的需求，比较成员变量的值，重写equals()即可。
* 自动生成即可。

*请用LinkedList模拟栈数据结构的集合，并测试
*题目的意思是：
* 你自己的定义一个集合类，在这个集合类内部可以使用LinkedList模拟。

 public class MyStack {
     private LinkedList link;
 
     public MyStack() {
         link = new LinkedList();
     }
 
     public void add(Object obj) {
         link.addFirst(obj);
     }
 
     public Object get() {
         // return link.getFirst();
         return link.removeFirst();
     }
 
     public boolean isEmpty() {
         return link.isEmpty();
     }
 }

* 集合也模仿着数组的这种做法，在创建对象的时候明确元素的数据类型。这样就不会在有问题了。
* 而这种技术被称为：泛型。
*
* 泛型：是一种把类型明确的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。参数化类型，把类型当作参数一样的传递。
* 格式：
* <数据类型>
* 此处的数据类型只能是引用类型。
* 好处：
* A:把运行时期的问题提前到了编译期间
* B:避免了强制类型转换
* C:优化了程序设计，解决了黄色警告线

// 创建集合对象
// JDK7的新特性：泛型推断。
// ArrayList<Student> array = new ArrayList<>();
// 但是我不建议这样使用。

* 早期的时候，我们使用Object来代表任意的类型。
* 向上转型是没有任何问题的，但是在向下转型的时候其实隐含了类型转换的问题。
* 也就是说这样的程序其实并不是安全的。所以Java在JDK5后引入了泛型，提高程序的安全性。

 public class ObjectTool {
     private Object obj;
 
     public Object getObj() {
         return obj;
     }
 
     public void setObj(Object obj) { // Object obj = new Integer(30);
         this.obj = obj;
     }
 }

 /*
  * 泛型类：把泛型定义在类上
  */
 public class ObjectTool<T> {
     private T obj;
 
     public T getObj() {
         return obj;
     }
 
     public void setObj(T obj) {
         this.obj = obj;
     }
 }

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

 public class ObjectTool {
     public <T> void show(T t) {
         System.out.println(t);
     }
 }

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

 public interface Inter<T> {
     public abstract void show(T t);
 }

 public class InterImpl<T> implements Inter<T> {
 
     @Override
     public void show(T t) {
         System.out.println(t);
     }
 }

// 泛型如果明确的写的时候，前后必须一致
Collection<Object> c1 = new ArrayList<Object>();
Collection<Object> c2 = new ArrayList<Animal>(); //报错
Collection<Object> c3 = new ArrayList<Dog>(); //报错

* 泛型高级(通配符)
* ?:任意类型，如果没有明确，那么就是Object以及任意的Java类了
* ? extends E:向下限定，E及其子类
* ? super E:向上限定，E极其父类

         // ?表示任意的类型都是可以的
         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>(); //报错

* JDK5的新特性：自动拆装箱,泛型,增强for,静态导入,可变参数,枚举
*
* 增强for:是for循环的一种。
*
* 格式：
* for(元素数据类型 变量 : 数组或者Collection集合) {
* 使用变量即可，该变量就是元素
* }
*
* 好处：简化了数组和集合的遍历。
*
* 弊端： 增强for的目标不能为null。
* 如何解决呢?对增强for的目标先进行不为null的判断，然后在使用。

// 说白了，这就是迭代器的功能

         if (list != null) {
             for (String s : list) {
                 System.out.println(s);
             }
         }

* 静态导入：
* 格式：import static 包名….类名.方法名;
* 可以直接导入到方法的级别
*
* 静态导入的注意事项：
* A:方法必须是静态的
* B:如果有多个同名的静态方法，容易不知道使用谁?这个时候要使用，必须加前缀。由此可见，意义不大，所以一般不用，但是要能看懂。
*/
import static java.lang.Math.abs;
import static java.lang.Math.pow;
import static java.lang.Math.max;

// 需求：我要写一个求和的功能，到底是几个数据求和呢，我不太清楚，但是我知道在调用的时候我肯定就知道了
// 为了解决这个问题，Java就提供了一个东西：可变参数

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

     public static int sum(int... a) {
         // System.out.println(a);
         //return 0;
 
         int s = 0;
 
         for(int x : a){
             s +=x;
         }
 
         return s;
     }

* public static <T> List<T> asList(T... a):把数组转成集合
*
* 注意事项：
* 虽然可以把数组转成集合，但是集合的长度不能改变。

         List<String> list = Arrays.asList("hello", "world", "java");
         // UnsupportedOperationException
         // list.add("javaee");
         // UnsupportedOperationException
         // list.remove(1);
         list.set(1, "javaee");
 
         for (String s : list) {
             System.out.println(s);
         }

* 获取10个1-20之间的随机数，要求不能重复

         // 创建产生随机数的对象
         Random r = new Random();
 
         // 创建一个存储随机数的集合。
         ArrayList<Integer> array = new ArrayList<Integer>();
 
         // 定义一个统计变量。从0开始。
         int count = 0;
 
         // 判断统计遍历是否小于10
         while (count < 10) {
             //先产生一个随机数
             int number = r.nextInt(20) + 1;
 
             //判断该随机数在集合中是否存在。
             if(!array.contains(number)){
                 //如果不存在:就添加，统计变量++。
                 array.add(number);
                 count++;
             }
         }
 
         //遍历集合
         for(Integer i : array){
             System.out.println(i);
         }
     }

* 键盘录入多个数据，以0结束，要求在控制台输出这多个数据中的最大值

         // 创建键盘录入数据对象
         Scanner sc = new Scanner(System.in);
 
         // 键盘录入多个数据,我们不知道多少个，所以用集合存储
         ArrayList<Integer> array = new ArrayList<Integer>();
 
         // 以0结束,这个简单，只要键盘录入的数据是0，我就不继续录入数据了
         while (true) {
             System.out.println("请输入数据：");
             int number = sc.nextInt();
             if (number != 0) {
                 array.add(number);
             } else {
                 break;
             }
         }
 
         // 把集合转成数组
         // public <T> T[] toArray(T[] a)
         Integer[] i = new Integer[array.size()];
         array.toArray(i);
 
         // 对数组排序
         // public static void sort(Object[] a)
         Arrays.sort(i);
 
         // 获取该数组中的最大索引的值
         System.out.println("数组是：" + arrayToString(i) + "最大值是:"
                 + i[i.length - 1]);
 
     public static String arrayToString(Integer[] i) {
         StringBuilder sb = new StringBuilder();
 
         sb.append("[");
         for (int x = 0; x < i.length; x++) {
             if (x == i.length - 1) {
                 sb.append(i[x]);
             } else {
                 sb.append(i[x]).append(", ");
             }
         }
         sb.append("]");
 
         return sb.toString();
     }