容器，类型转换。List。

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_43147136/article/details/82965960

一、容器

二、集合接口

• 1 Collection 接口

Collection 是最基本的集合接口，一个 Collection 代表一组 Object，即 Collection 的元素, Java不提供直接继承自Collection的类，只提供继承于的子接口(如List和set)。

• 2 List 接口

List接口是一个有序的 Collection，使用此接口能够精确的控制每个元素插入的位置，能够通过索引(元素在List中位置，类似于数组的下标)来访问List中的元素，第一个元素的索引为 0，而且允许有相同的元素。

• 3 Set接口

Set 具有与 Collection 完全一样的接口，只是行为上不同，Set 不保存重复的元素。

• 4 Map接口

将唯一的键映射到值。

三、List接口及其实现类—ArrayList（数组序列）

1.List是元素有序并且可以重复的集合，被称为序列。

2.List可以精确的控制每个元素的插入位置，或删除某个位置的元素。

3.ArrayList–数组序列，是List的一个重要实现类

ArrayList类的构造方法有3种重载方式

1.构 造 方 法

• ArrayList()

创建一个空的ArrayList对象

• ArrayList(Collection c)

根据指定的集合创建ArrayList对象

• ArrayList(int initialCapacity)

使用给定的大小创建ArrayList对象

2.方 法 原 型

实例：

public class ArrayTest {

public static void main(String[] args) {

    //创建一个空ArrayList对象
    ArrayList arrayList = new ArrayList();
    //添加10次需要借用for循环语句
    for (int i = 0; i < 10; i++) {
        //创建整型包装类对象
        Integer integer = new Integer(i);
        //将该对象存放到ArrayList中
        arrayList.add(integer);
    }
    System.out.println("数组中的元素：");
    //遍历输出：arrayList
    for (int i = 0; i < arrayList.size(); i++) {
        Integer in = (Integer) arrayList.get(i);
        System.out.println(in);
    }
    System.out.println("*********************************");
    //清空
    arrayList.clear();
    System.out.println("数组被清空后的情况：");
    System.out.println("数组长度为：" + arrayList.size());

    if (arrayList == null && arrayList.isEmpty()){
        System.out.println("数组现在为空");
    } else {
        System.out.println("数组不为空");
    }
}
}

深度理解ArrayList

• ArrayList实现了List接口,它是以数组的方式来实现的,数组的特性是可以使用索引的方式来快速定位对象的位置,因此对于快速的随机取得对象的需求,使用ArrayList实现执行效率上会比较好.
• 这里列举出了循环List列表的三种方式: 使用普通for循环,用get方法获取; 使用Iterator迭代器,使用next方法遍历;使用增强for循环,直接输出! 由此可见第三种方法是最方便，最简洁的!

实例1：

创建一个空ArrayList对象
ArrayList arrayList = new ArrayList();
//添加10次用for循环：
for(int i = 0;i < 10; i++ ){
    //创建整型包装类对象
    Integer integer = new Integer(i);
    //将该对象存放到ArrayList中
    arrayList.add(integer);
}
//遍历输出ArrayList:
for (int i = 0;i < arrayList.size();i++){
    Integer in = (Integer)arrayList.get(i);
    System.out.println(in);
}

实例2：

public class ArrayListDemo {
    public static void main(String[] args) {
        //用泛型创建List对象
        List<String>userlist = new ArrayList<String>();
            userlist.add("丰泽");
            userlist.add("与龙共舞");
        System.out.println("使用普通for循环");
       //   方法一： 遍历输出userList对象
        for (int i = 0; i <userlist.size() ; i++) {
            System.out.println(userlist.get(i));
        }
        System.out.println();
        System.out.println();

        //  方法二：
        System.out.println("使用Iterator迭代器:");
        Iterator iterator = userlist.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next()+"");
        }
        System.out.println();
        System.out.println();


        //  方法三：
        System.out.println("使用增强for循环：");
        for (String s:userlist){
            System.out.println(s+"");
        }

    }
}

四、LinkedList类

• LinkedList类用于创建链表数据结构；

• 链表中元素的数量不受任何限制，可以随意地添加和删除；

• 与ArrayList相比，如果需要频繁地添加和删除元素，LinkedList的性能更加优越；

• LinkedList类继承了AbstractSequentialList类，并实现了List接口

1.LinkedList类的构造方法

• LinkedList()

创建一个空链表

• LinkedList(Collection c)

根据指定的集合创建链表

2.LinkedList类的常用方法

• int size()

返回链表的大小，即元素的数量

• boolean isEmpty()

判断链表是否为空，为空返回true，否则返回false

• void clear()

清空链表中的所有元素，使其成为空链表

• boolean add(Object element)

向链表中添加一个元素，该元素可以是任何类的对象

• Object remove(int index)

从链表中删除指定索引位置的元素

• Object get(int index)

返回指定索引位置的元素

• Object set(int index, Object elem)

将元素elem存放到由index指定的索引位置上

• int indexOf(Object element)

判断element在链表中是否存在，存在返回对应的索引，否则返回-1

3.方法原型

实例：

public class LinkedTest {

public static void main(String[] args) {

    //创建空的链表
    LinkedList linkedList = new LinkedList();

    for (int i = 0; i < 10; i++) {
        //创建包装类对象
        Double temp = new Double(i);
        //将包装类对象添加到链表中
        linkedList.add(temp);
    }
    //循环打印链表中的元素
    for (int i = 0; i < linkedList.size(); i++) {
        System.out.println(linkedList.get(i));
    }
    System.out.println("*********************************");
    linkedList.removeFirst();  //删除第一个元素
    linkedList.removeLast();   //删除最后一个元素

    System.out.println("删除第一个元素和最后一个元素后的链表：");
    for (int i = 0; i < linkedList.size(); i++) {
        System.out.println(linkedList.get(i));
    }
    运行结果：0123456789 ********************************* 数组被清空后的情况： 数组长度为：0 数组不为空

深度理解LinkedList

• 1.LinkedList是采用链表的方式来实现List接口的,它本身有自己特定的方法，如: addFirst(),addLast(),getFirst(),removeFirst()等. 由于是采用链表实现的,因此在进行insert和remove动作时在效率上要比ArrayList要好得多!适合用来实现Stack(堆栈)与Queue(队列),前者先进后出，后者是先进先出.
• 2、如果要使用队列的功能,由于LinkedList也实现了java.util.Queue接口,所以可以直接使用LinkedList的实例来实现.

 //父类引用queue指向子类对象  
        Queue<String> queue = new LinkedList<String>();  
//offer()方法是往队列加入元素  
        queue.offer("xiaoyun");  

public class StringStack {
    private LinkedList<String> linkedList = new LinkedList<String>();

    /**
     * 将元素加入到LinkedList容器
     * （就是插入到链表的第一个位置）
     */
    public void put(String name) {
        linkedList.addFirst(name);
    }

    /**
     * 取出堆栈中最上面的元素
     * （就是取出链表linkedList的第一个元素)
     * 最后return
     */
    public String getTop() {
        return linkedList.getFirst();
    }

    /**
     * 取出并删除最上面的元素
     * （就是移除linkedList的第一个元素）
     * 最后return
     */
    public String pop() {
        return linkedList.removeFirst();
    }

    /**
     * 获取元素个数
     * 最后return
     */
    public int size() {
        return linkedList.size();
    }

    /**
     * 判断堆栈是否为空
     * 就是判断LinkedList是否为空
     * 最后return
     */
    public boolean isEmpty() {
        return linkedList.isEmpty();
    }

    /**
     * 测试
     */
    public static void main(String[] args) {
        LinkedList<Object> linkedList = new LinkedList<Object>();
        ArrayList<String> arrayList = new ArrayList<String>();
        for (int i = 0; i <5 ; i++) {
            arrayList.add(Integer.toString(i));
        }
        linkedList.add(arrayList);
        linkedList.add("学习");
        linkedList.add("快乐");
        for (Object d : linkedList) {
            if(d instanceof ArrayList){
                System.out.println("是array");
            }else {
                continue;
            }
            System.out.println(d);
        }
        linkedList.clear();
        if (linkedList.isEmpty() && linkedList ==null){
            System.out.println("链表为空");
        }else {
            System.out.println("链表不为空");
        }

    }
}
运行结果：
是array
[0, 1, 2, 3, 4]
链表不为空

关于：在删除可插入对象的动作时，为什么ArrayList的效率会比较低呢?

解析: 因为ArrayList是使用数组实现的,若要从数组中删除或插入某一个对象，需要移动后段的数组元素，从而会重新调整索引顺序,调整索引顺序会消耗一定的时间，所以速度上就会比LinkedList要慢许多. 相反,LinkedList是使用链表实现的,若要从链表中删除或插入某一个对象,只需要改变前后对象的引用即可!

五、Vector类

• Vector类与ArrayList类和LinkedList类很相似，最大的区别在于Vector是线程同步的；

• 如果在多线程的程序中要使用到集合框架，并且不希望线程与线程之间相互干扰，那么Vector是不错的选择；

• Vector类继承于AbstractList类，并实现了List接口

1.构 造 方 法

• Vector()

创建一个空的Vector对象。初始容量为10，容量增量为0

• Vector(Collection c)

根据指定的集合创建Vector对象

• Vector(int initialCapacity)

创建一个Vector对象，初始容量由initialCapacity指定，容量增量为0

• Vector(int initialCapacity,int capacityIncrement)

创建一个Vector对象，初始容量由initialCapacity指定，容量增量由capacityIncrement指定

2.常用方法

3.方法原型

实例：

public class VectorTest {

public static void main(String[] args) {
    //创建一个空的Vector对象。初始容量为10，容量增量为0
    Vector vector = new Vector();
    //向Vector对象中添加一个元素，该元素可以是任何类的对象
    vector.add("a");
    vector.add("b");
    vector.add("c");
    vector.add("d");

    //将指定元素插入到指定索引位置
    vector.insertElementAt("王聪聪",3);

    for (int i = 0; i <vector.size() ; i++) {
        System.out.println(vector.get(i));
        
        运行结果：a b c 王聪聪 d 

五、类型转换

其中基本数据类型转换为字符串有三种方法：

• 1.使用包装类的toString()方法

• 2.使用String的valueOf()方法

• 3.用一个空字符串加上基本类型，得到的就是基本类型数据对应的字符串。

实例：

//int转String

int id = 10;

String name = Integer.toString(id);

String name2 = String.valueOf(id);

String name3 = id + “”;

//String转int

String Str = “8”;

int t = Integer.parseInt(Str);

int tt = Integer.valueOf(Str);