ArrayList,LinkedList和String

客官°小女子只卖身不卖艺 2021-09-16 15:26 422阅读 0赞

![标题图][1240]

import java.util.ArrayList;
    public class Demo{
     public static void main(String[] args) throws Exception {
       ArrayList<Integer> arrayList = new ArrayList<>();
       arrayList.add(1);
       arrayList.add(2);
       arrayList.add(3);
       for(Integer integer : arrayList){
        arrayList.remove(1);
       }
     }
    }

异常的出现:

![描述][1240 1]

Exception in thread "main" java.util.ConcurrentModificationException

如果换为

for(Integer integer : arrayList){
     System.out.println(arrayList.remove(0));
    }

那么显示台为:

![描述][1240 2]

1
    Exception in thread "main" java.util.ConcurrentModificationException

这样的话把 `arrayList.remove( )` 中的数字改为 0, 1, 2, 的话,显示台会出现 1, 2, 3, 的.

import java.util.ArrayList;
    public class Demo {
    	public static void main(String[] args) throws Exception{
    		ArrayList<Integer> arrayList = new ArrayList<>();
    		arrayList.add(1);
    		arrayList.add(2);
    		arrayList.add(3);
    		for(Integer integer : arrayList){
    		   System.out.println(arrayList.remove(0));
    		   break;
    		}
    	}
    }

这样控制台显示为:

// 显示为 1
    1

> 集合是用来存储一些变量

`Collection`的一些常见方法:

size()
    isEmpty(()
    contains(Object)
    toArray()
    toArray(T[])
    add(E)
    remove(Object)
    containsAll(Collection<?>)
    addAll(Collection<? extends E>)
    retainAll(Collection<?>)
    clear()
    stream()

`ArrayList`

// 源码:
    public class ArrayList<E> extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable
    // 再次往上走
    public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E>
    // 再次往上走
    public abstract class AbstractCollection<E> implements Collection<E>

在上述代码中，有可能看到的异常会有所不理解。因为无法在迭代的过程中进行修改，只能读而已。因为是一个临时的储存空间。如果要用可以如下：

import java.util.ArrayList;
    import java.util.Iterator;
    public class Demo {
    	public static void main(String[] args) throws Exception{
    		ArrayList<Integer> arrayList = new ArrayList<>();
    		arrayList.add(11);
    		arrayList.add(21);
    		arrayList.add(31);
    //		for(Integer integer : arrayList){
    //		   System.out.println(arrayList.remove(0));
    //		   break;
    //		}
    		
    		System.out.println(arrayList.size());
    		for (int i = 0,length = arrayList.size(); i <length ; i++) {
    			System.out.println(i);
    			arrayList.remove(0);
    		}
    		System.out.println(arrayList.size());
    	}
    }

public class Demo {
    	 Object[] object2;
    	 public static Object[] objects = {};
    	 public void test(){
    	  System.out.println(objects == object2);
    	 }
    	public static void main(String[] args) throws Exception{
    		Demo n = new Demo();
    		System.out.println(n.object2);
    		System.out.println(objects);
    		new Demo().test();
    	}
    }

![描述][1240 3]

在集合初始化时,要尽量指定集合的初始值大小,在`ArrayList`中,要多多使用`ArrayList(int initialCapacity)`的初始化.

`ArrayList`中的内存地址是连续的,它存放的是连续的,如`1,2,3,4,5`等,可以通过索引找到自己想要,因为是连续的,所以马上就可以找到自己想要的了.

在`LinkedList`中是处于不同的内存地址的,每个元素存储的空间有个文件指针是指向下一个元素的,只有当它进行迭代后,才能找到.

## `Class ArrayList<E>` ##

`java.lang.Object`  
`->java.util.AbstractCollection<E>`  
`->java.util.AbstractList<E>`  
`->java.util.ArrayList<E>`

所有实现的接口:

`Serializable, Cloneable, Iterable<E>, Collection<E>, List<E>, RandomAccess`

知道的子类:

`AttributeList, RoleList, RoleUnresolveList`

完整结构:

`public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable`

`ArrayList`是可以调整数组大小,实现`List`的接口.`ArrayList`是基于实现动态数据的数据结构哦,进行随机访问比较容易,用`get`和`set`方法~

![描述][1240 4]

## `Class LinkedList<E>` ##

`java.lang.Object`  
`->java.util.AbstractCollection<E>`  
`->java.util.AbstractList<E>`  
`->java.util.AbstractSequentialList<E>`  
`->java.util.LinkedList<E>`

参数类型 `E` 为这个集合中要保持的数据类型.

完整结构:

`public class LinkedList<E>`  
`extends AbstractSequentialList<E>`  
`implements List<E>, Deque<E>, Cloneable, Serializable`

![描述][1240 5]

`LinkedList` 是使用了循环双向链表数据结构,`LinkedList`链表是由 元素内容,前驱表和后驱表, 一系列表项连接而成的.

链表内是由一个`header`的表项是作为链表的开始,也同样有链表的结尾.在链表中表项头`header`的后驱表项就是链表中第一个元素,而表项`header`的前驱就是链表的最后一个元素.

> 数组:数组是连续存储的,所以它的索引非常的快,在内存中赋值和修改也很容易.

`int[] arr = new int[3];`

`int[] arr = new int[3] {1,2,3};`

`int[] arr = {1,2,3,4};`

在数组中一定存在着它不好的缺点,因为如果在我们不知道数组的长度情况下会很麻烦,声明数组一定要指定它的长度,如果这个长度太长,就会导致浪费内存,如果过短的情况下又会导致数据溢出的结果.

这时上帝创建了`ArrayList`的类,使用这个类就必须要进行引用,然后继承接口,在`ArrayList`对象的大小是可以动态改变的,不像数组那样死板固定化,可以自由扩展和收缩存储的数据.

创建对象:

`ArrayList arrayList = new ArrayList();`

添加数据等等:

`arrayList.add("dashucoding");`

> 在`LinkedList`都是指针指向下一个元素,如果中间有进行删减,那么后面的元素会提前到前面空缺的位置,后面的也一样.所以`LinkedList`比较麻烦的,`LinkedList`是基于链表的数据结构哦~

## 总结`LinkedList`和`ArrayList` ##

`ArrayList`比较好访问`get`和`set`,而`LinkedList`比较好增加和删除`add`和`remove`.都是为了防止移动数据嘛,移动就会比较麻烦嘛~

import java.util.LinkedList;
    public class Demo{
     public static void main(String[] args){
      LinkedList<Integer> linkedList = new LinkedList<>();
      linkedList.add(1);
     }
    }

// add方法
    public boolean add(E e){
     // 插入到最后一位
     linkLast(e);
     // 返回为true
     return true;
    }

// 最尾
    void linkLast(E e){
     // last赋给l, 初始Last为空
     final Node<E> l = last;
     final Node<E> newNode = new Node<>(1,e,null);
     // 更新Last指针指向新的节点
     last = newNode;
     if(l == null){
      // 如果为第一次插入,就将first指针指向第一个节点
      first = newNode;
     }else{
      // 如果有了头节点,就将l指针的next指向新节点
      l.next = newNode;
     }
     // 链表大小加一
     size++;
     // 修改次数加一
     modCount++;
    }

// LinkedList$Node.class 内部类,静态类
    private static class Node<E> {
     // 数据位
     E item;
     // 指针
     Node<E> next;
     Node<E> prev;
     // 构造器
     Node(Node<E> prev, E element, Node<E> next){
      this.item = element;
      this.next = next;
      this.prev = prev;
     }
    }
    // since 1.6
    public Iterator<E> descendingIterator(){
     return new DescendingIterator();
    }

transient Node<E> last;

public int size(){
     return size;
    }

> `ArrayList<E>`

public ArrayList() {
     this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    // 构造一个空的对象数组
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    // 调用方法
    ensureCapacityInternal(size+1);
    // list内部日期是否有多余空间

if(elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA){
     minCapacity=Math.max(DEFAULT_CAPACITY,minCapacity);
    }
    ensureExplicitCapacity(minCapacity);
    // 记录下数据的修改次数
    modCount++;
    if(minCapacity - elementData.length > 0)
    grow(minCapacity);

private void grow(int minCapacity){
     int oldCapacity = elementData.length;
     int newCapacity = oldCapacity + (oldCapacity >> 1);
     if(newCapacity - minCapacity < 0)
      newCapacity = minCapacity;
     if(newCapacity - MAX_ARRAY_SIZE > 0)
      newCapacity = hugeCapacity(minCapacity);
     elementData = Arrays.copyOf(elementData,newCapacity);
    }

![描述][1240 6]

![描述][1240 7]

![描述][1240 8]

![描述][1240 9]

package day1;
    public class Demo {
    	public static Object[] objects = {};
    	public static void main(String[] args) throws Exception{
    		System.out.println(objects.getClass());
    	}
    }

![描述][1240 10]

package day1;
    public class Demo {
    	public static Object[] objects = {};
    	public static void main(String[] args) throws Exception{
    		System.out.println((Object)objects.getClass());
    	}
    }

不变:

![描述][1240 11]

public class Demo {
    	public static Object[] objects = {};
    	public static void main(String[] args) throws Exception {
    		System.out.println((Object)objects == (Object)objects.getClass());
    	}
    }
    // false

public class Demo {
    	public static Object[] objects = {};
    	public static void main(String[] args) throws Exception{
    		System.out.println((Object)objects == (Object)Object[].class);
    	}
    }
    // false

package day1;
    public class Demo {
    	String string = "dashucoding";
    	public static void main(String[] args) throws Exception{
    	 String string = "dashucoding";
    	 System.out.println(string.getClass()==String.class);
    	}
    }
    // 为true

public static Object[] objects = {};
    objects.getClass() == Object[].class
    objects instanceof Object[]

## String ##

> `Class String`

`java.lang.Object`  
`java.lang.String`

`public final class String extends Object implement Serializable, Comparable<String>, CharSequece`

`String`类表示为字符串,所有的字符串都被实现为此类的实例,字符串是不可以变的,它们的值在创建后不可以改变,字符串缓冲区是支持可变的字符串的.

字符串:

String str = "dashucoding";

等于:

char data[] = { 'da', 'shu', 'coding'};
    String str = new String (data);

例子:

public class Demo {
    	public static void main(String[] args) throws Exception{
    		System.out.println("cat");
    		// cat
    	    String a = "mouse";
    	    System.out.println("cat" + " " + a);
    	    // cat mouse
    	    String c = "cat".substring(2,3);
    	    System.out.println(c);
    	    // s
    	    String d = a.substring(1, 2);
    	    // o
    	    System.out.println(d);
    	}
    }

![描述][1240 12]

`String`类可以用于比较字符串,搜索字符串,提取字符串等等,各种方法,字符串的连接可以用`+`这个运算符,但是`Java`提供了`StringBuilder`和`StringBuffer`类,通过用`append`方法实现连接,字符串方法还可以用`toString`的方法进行字符串的转换.

抛出异常:如果字符串传值为`null`的时候,会抛出`NullPointerException`.

`public String toString()`

`toString`用来返回对象的字符串表现形式

## `Class StringBuffer` ##

`java.lang.Object`  
`java.lang.StringBuffer`

`public final class StringBuffer extends Object implements Serializable, CharSequence`

`StringBuffer`线程安全,是可变的字符序列,字符串在缓冲区中可以修改,在`StringBuffer`中是常常用到`append`方法和`insert`的方法.通过这些方法进行将数据转换为字符串,把字符串加载到字符串缓冲区中.

`append()`的方法是用于在缓冲区中的末尾添加这些字符,和`insert()`方法是将数据添加到指定的位置.

> 案例:

比如在字符缓冲区中已经有对象`dashu`用`a`进行表示,然后调用`a.append("coding");`,而`insert()`插入的方法也容易,参数两个,第一个为插入的位置,第二个为插入的数据而已.

> 注意每个字符串缓冲区是由属于它自己的容量的,如果内部的缓冲区溢出,就会导致自动变大,如果够用,就不会被分析新的.`StringBuffer`通常用单个线程字符串缓冲区的地方.

## `Class StringBuilder` ##

`java.lang.Object`  
`java.lang.StringBuilder`

`public final class StringBuilder extends Object implements Serializable, CharSequence`

`StringBuilder`也是一个可变的资产.同样也有`append()`方法和`insert()`的方法,有了`StringBuilder`的出现,`StringBuffer`都靠边了.但是如果有多线程就不能够安全的使用了,就要改换使用`StringBuffer`了.

> 往后余生，唯独有你  
> 简书作者：达叔小生  
> 90后帅气小伙，良好的开发习惯；独立思考的能力；主动并且善于沟通  
> 简书博客： [https://www.jianshu.com/u/c785ece603d1][https_www.jianshu.com_u_c785ece603d1]

## 结语 ##

*  下面我将继续对 其他知识 深入讲解 ，有兴趣可以继续关注
 *  小礼物走一走 or 点赞

[1240]: /images/20210724/f32e5d7bb57d48379d82309a2fca0f7c.png
[1240 1]: /images/20210724/9288139d0ac64d2c9351f7618d07afe4.png
[1240 2]: /images/20210724/921e2ddb3def4e97b540e38d263bd7b7.png
[1240 3]: /images/20210724/36f5f75202d843a9a08cf06f20df7326.png
[1240 4]: /images/20210724/9879ef345c49464f88121bbb60dc7f3c.png
[1240 5]: /images/20210724/ba68b911ce0a4c3f8852febad136c89e.png
[1240 6]: /images/20210724/eb6eecc4134d43f6ac38f35fce0f92ae.png
[1240 7]: /images/20210724/04ded1a9f42a473bacfc65d3121a2d46.png
[1240 8]: /images/20210724/d81752ec302e4308a73e2e0c2e7a024d.png
[1240 9]: /images/20210724/b9221b7be4d24ed1b45bb2271a73b0ea.png
[1240 10]: /images/20210724/b2f4f43140ae49b8b530025bd1740a1e.png
[1240 11]: /images/20210724/644d521d29734b6a9b173997d33eb005.png
[1240 12]: /images/20210724/c49db743c52443bea39d81b78528728f.png
[https_www.jianshu.com_u_c785ece603d1]: https://www.jianshu.com/u/c785ece603d1