ArrayList,LinkedList和String

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

Exception in thread "main" java.util.ConcurrentModificationException

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

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

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

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

// 源码:
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();
	}
}

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

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

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

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

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