Java之ArrayList、Vector、LinkedList和泛型以及增强for循环

1. ArrayList

1.1ArrayList存储字符串并遍历

package kscng;
 
import java.util.ArrayList;
import java.util.Iterator;
 
/*
 * ArrayList的使用。
 *         存储字符串并遍历。
 */
public class ArrayList {
    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
        for(int x = 0;x<al.size();x++){
            String s = (String) al.get(x);
            System.out.println(s);
        }
    }
}

1.2 ArrayList存储自定义对象并遍历

package kscng;
import java.util.ArrayList;
import java.util.Iterator;

public class Arraylist{
public static void main(String []args) {
ArrayList <shape>Array = new ArrayList<shape>();
shape rec = new rectangle(0.9,0.1,90.0);        //   类 rectangle   Square circle 是 shape 的子类
shape squ = new Square(0.7,0.3,90.0);
shape cir = new circle(0.5,0.5,10.0);
Array.add(rec);              //   添加对象
Array.add(squ);
Array.add(cir);
Iterator <shape>it = Array.iterator();
while(it.hasNext()) {                 // 循环遍历arrylist
 shape T = (shape)it.next();
 System.out.println(T.GetX()+"  "+T.GetY()+"  "+T.GetA());      
  // System.out.println(it.next());   //  输出类名 和hashcode
   
}
}
}
class shape extends Turtle{
double x;
double y;
double a;
public shape(double x0,double y0,double a0) {
super(x0,y0,a0);
}
public double GetX() {
return x;
}
public void SetX(double x0) {
this.x=x0;
}
public double GetY() {
return y;
}
public void SetY(double y0) {
this.y=y0;
}
public double GetA() {
return a;
}
public void SetA(double a0) {
this.a=a0;
}

}

1.3 LinkedList的特有功能

LinkedList类概述:  List 接口的链接列表实现 , 此实现不是同步的

 List的子类特点:
 ArrayList:
底层数据结构是数组,查询快,增删慢
线程不安全,效率高

 LinkedList:
底层数据结构是链表,查询慢,增删快
线程不安全,效率高

1.4用LinkedList模拟栈数据结构的集合并测试

演示:    

需求：请用LinkedList模拟栈数据结构的集合，并测试。

package kscng;

import com.sun.media.sound.SoftTuning;
public class MyTest {
    public static void main(String[] args) {
      
        MyStack myStack = new MyStack();
        myStack.addEle(100);
        myStack.addEle(200);
        myStack.addEle(300);
        myStack.addEle(400);
        myStack.addEle(500);

        Object o = myStack.get();
        System.out.println(o);
        Object o2 = myStack.get();
        System.out.println(o2);

        Object o3 = myStack.get();
        System.out.println(o3);
        Object o4 = myStack.get();
        System.out.println(o4);
        Object o5 = myStack.get();
        System.out.println(o5);
        Object o6= myStack.get();
        System.out.println(o6);
    }
}

package kscng;

import java.util.LinkedList;
import java.util.function.Consumer;
public class MyStack {
    LinkedList linkedList;
    public MyStack() {
        linkedList= new LinkedList();
    }

    public void addEle(Object obj){
        linkedList.addFirst(obj);
    }

    public Object get(){
        //linkedList.forEach(new Consumer() {
        //    @Override
        //    public void accept(Object o) {
        //        System.out.println(o);
        //    }
        //});
        //System.out.println(linkedList);
        //将第一个元素取出，并删除他
        Object poll = linkedList.poll();
        linkedList.addLast(poll);

        return poll;

    }

}

1.5 去除ArrayList中重复字符串元素方式

演示
    需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)
    思路：创建新集合方式

package kscng;

import java.util.ArrayList;
public class MyTest {
    public static void main(String[] args) {

        ArrayList list = new ArrayList();
        list.add("abc");
        list.add("bbb");
        list.add("abc");
        list.add("abc");
        list.add("ccc");
        list.add("ddd");
        list.add("ccc");
        list.add("ddd");
        ArrayList newList = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            String s = (String) list.get(i);
            if(!newList.contains(s)){
                newList.add(s);
            }
        }

        System.out.println(newList);

    }
}

1.6 去除ArrayList中重复自定义对象元素

演示
        需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)
        思路：创建新集合方式

package kscng;

import java.util.ArrayList;
public class MyTest {
    public static void main(String[] args) {

           ArrayList list = new ArrayList();
        list.add("abc");
        list.add("bbb");
        list.add("abc");
        list.add("abc");
        list.add("ccc");
        list.add("ddd");
        list.add("ccc");
        list.add("ddd");
        ArrayList newList = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            String s = (String) list.get(i);
            if(!newList.contains(s)){
                newList.add(s);
            }
        }

        System.out.println(newList);

    }
}

2. Vector

2.1Vector的特有功能

Vector类概述:    Vector 类可以实现可增长的对象数组 

Vector 是同步的。

Vector类特有功能

public E elementAt(int index)

public void addElement(E obj)

public Enumeration elements()

3.泛式

3.1泛型概述和基本使用

泛型概述:是一种把类型明确的工作推迟到创建对象，或者调用方法的时候才去明确的特殊的类型。

参数化类型，把类型当作参数一样的传递。

泛型的格式    :    <数据类型>    这里的数据类型只能是引用数据类型

public class 类名<数据类型 , ....> {}

public class ObjectTools<K> {

private K k ;

public K getK() { return k; }

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

}

泛型好处

    (1): 把运行时期的问题提前到了编译期间
    (2): 避免了强制类型转换
    (3):优化了程序设计，解决了黄色警告线

3.2泛型方法的概述和使用

泛型方法概述:    把泛型定义在方法上

定义格式:        public <泛型类型> 返回类型 方法名(泛型类型 变量名)

演示

泛型方法的使用
public class Phone {

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

}

3.3泛型接口的概述和使用

泛型接口概述:    把泛型定义在接口上

定义格式:        public interface 接口名<泛型类型>

演示:        泛型接口的使用
public interface Inter<T> {

public abstract void show(T t) ;

}

3.3.1

泛型接口的子类: 第一种情况: 就是在定义子类的时候我们已经可以明确数据类型了

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

}

}

4.增强for的概述和使用

增强for概述

简化数组和Collection集合的遍历

格式：

for(元素数据类型 变量 : 数组或者Collection集合) {
        使用变量即可，该变量就是元素
    }

好处和注意事项

简化遍历
    注意事项：增强for的目标要判断是否为null

4.1ArrayList存储字符串并遍历增强for版

public class MyTest {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList();
        list.add(100);
        list.add(100);
        list.add(100);
        list.add(100);
        list.add(100);
        list.add(100);
        list.add(100);
        list.add(100);
        list.add(100);
        list.add(100);
        list.add(100);
        list.add(100);

for(int a:arr){
          System.out.println(a);
        }

    }

}

5.可变参数

5.1可变参数的概述和使用

可变参数概述:    定义方法的时候不知道该定义多少个参数

格式:            修饰符 返回值类型 方法名(数据类型…  变量名){}

注意事项：

这里的变量其实是一个数组。

如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个。

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

5.2Arrays工具类的asList()方法的使用

Arrays工具类的asList(T... t)方法的使用:

将数组转换成集合

注意事项:    

得到的集合长度是不可变的 你不能往这个转换后的集合中 添加元素（add） 和 删除元素(remove)

只能获取元素(get)

5.3集合嵌套之ArrayList嵌套ArrayList

需求：

a.我们学科，学科又分为若干班级

b.整个学科一个大集合

c.若干个班级分为每一个小集合

集合嵌套之ArrayList嵌套ArrayList

package kscng;
 
import java.util.ArrayList;
 
import kscng.collection.bean.Person;
 

public class ArrayListArraylist {
    public static void main(String[] args) {
        ArrayList<ArrayList<Person>> list = new ArrayList<ArrayList<Person>>();
        //创建第一个班级
        ArrayList<Person> first = new ArrayList<Person>();
        first.add(new Person("张三",30));
        first.add(new Person("李四",27));
        first.add(new Person("王五",33));
        first.add(new Person("赵六",20));
        first.add(new Person("秦七",35));
        //再创建一个班级集合
        ArrayList<Person> second = new ArrayList<Person>();
        second.add(new Person("周八",33));
        second.add(new Person("吴九",40));
        second.add(new Person("郑王",29));
        second.add(new Person("梁凉",36));
        
        //将班级添加到学科中
        list.add(first);
        list.add(second);
        //遍历学科集合,循环嵌套循环
        for (ArrayList<Person> array : list) {
            for (Person person : array) {
                System.out.println(person);
            }
        }
//         运行结果：
//            Person [age=30, name=张三]
//            Person [age=27, name=李四]
//            Person [age=33, name=王五]
//            Person [age=20, name=赵六]
//            Person [age=35, name=秦七]
//            Person [age=33, name=周八]
 //           Person [age=40, name=吴九]
//            Person [age=29, name=郑王]
 //           Person [age=36, name=梁凉] 
    }
}