迭代器遍历列表 构造方法 constructor ArrayList Vector LinkedList Array List 时间复杂度

package priceton;

import java.io.IOException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class RecipesCyclicBarrier {
	public static CyclicBarrier barrier = new CyclicBarrier(3);

	public static void main(String[] args) throws IOException, InterruptedException {
		ExecutorService executor = Executors.newFixedThreadPool(3);
		executor.submit(new Thread(new Runner("NO-1")));
		executor.submit(new Thread(new Runner("NO-2")));
		executor.submit(new Thread(new Runner("NO-3")));
		executor.shutdown();
	}
}

class Runner implements Runnable {
	private String name;

	public Runner(String name) {
		this.name = name;
	}

	public void run() {
		System.out.println(name + " READY!");
		try {
			RecipesCyclicBarrier.barrier.await();
		} catch (Exception e) {
		}
		System.out.println(name + " GO!");
	}

}

　　

package priceton;
import java.util.*;
public class ArrayListTest {
	 public static void main(String[] args) {
	     List<String> list=new ArrayList<String>();
	     list.add("Hello");
	     list.add("World");
	     list.add("HAHAHAHA");
	     //第一种遍历方法使用foreach遍历List
	     for (String str : list) {            //也可以改写for(int i=0;i<list.size();i++)这种形式
	        System.out.println(str);
	     }

	     //第二种遍历，把链表变为数组相关的内容进行遍历
	     String[] strArray=new String[list.size()];
	     list.toArray(strArray);
	     for(int i=0;i<strArray.length;i++) //这里也可以改写为  foreach(String str:strArray)这种形式
	     {
	        System.out.println(strArray[i]);
	     }

	    //第三种遍历 使用迭代器进行相关遍历

	     Iterator<String> ite=list.iterator();
	     while(ite.hasNext())//判断下一个元素之后有值
	     {
	         System.out.println(ite.next());
	     }
	 }
}

　　

Java菜鸟教程 面向对象（二）——constructor、overload与一个练习 - CSDN博客 https://blog.csdn.net/thomasli2017/article/details/77338454

Java 对象和类 | 菜鸟教程 http://www.runoob.com/java/java-object-classes.html

Java中类的构造方法 - CSDN博客 https://blog.csdn.net/zw1996/article/details/52878270

Providing Constructors for Your Classes (The Java™ Tutorials > Learning the Java Language > Classes and Objects) https://docs.oracle.com/javase/tutorial/java/javaOO/constructors.html

Providing Constructors for Your Classes

【使用类名。没有返回】

A class contains constructors that are invoked to create objects from the class blueprint. Constructor declarations look like method declarations—except that they use the name of the class and have no return type. For example, Bicycle has one constructor:

public Bicycle(int startCadence, int startSpeed, int startGear) {
gear = startGear;
cadence = startCadence;
speed = startSpeed;
}
To create a new Bicycle object called myBike, a constructor is called by the new operator:

Bicycle myBike = new Bicycle(30, 0, 8);
new Bicycle(30, 0, 8) creates space in memory for the object and initializes its fields.

Although Bicycle only has one constructor, it could have others, including a no-argument constructor:

public Bicycle() {
gear = 1;
cadence = 10;
speed = 0;
}
Bicycle yourBike = new Bicycle(); invokes the no-argument constructor to create a new Bicycle object called yourBike.

Both constructors could have been declared in Bicycle because they have different argument lists. As with methods, the Java platform differentiates constructors on the basis of the number of arguments in the list and their types. You cannot write two constructors that have the same number and type of arguments for the same class, because the platform would not be able to tell them apart. Doing so causes a compile-time error.

You don't have to provide any constructors for your class, but you must be careful when doing this. The compiler automatically provides a no-argument, default constructor for any class without constructors. This default constructor will call the no-argument constructor of the superclass. In this situation, the compiler will complain if the superclass doesn't have a no-argument constructor so you must verify that it does. If your class has no explicit superclass, then it has an implicit superclass of Object, which does have a no-argument constructor.

You can use a superclass constructor yourself. The MountainBike class at the beginning of this lesson did just that. This will be discussed later, in the lesson on interfaces and inheritance.

You can use access modifiers in a constructor's declaration to control which other classes can call the constructor.

https://mp.weixin.qq.com/s/0W7-wAwonXLtV4D0uQBuxQ

ArrayList 的实现原理，如何测试 ArrayList 动态分配内存带来的内存、CPU 变化？

• ArrayList 是用数组实现的，这个数组在内存中是连续的

• 索引 ArrayList 时，速度比原生数组慢是因为你要用 get 方法，这是一个函数调用，而数组直接用下标访问，相当于直接操作内存地址，速度当然非常快

• 新建 ArrayList 的时候，JVM 为其分配一个默认或指定大小的连续内存区域

• 每次增加元素会检测容量，不足则创建新的连续内存区域，并将原来的内存区域数据复制到新的内存区域，然后再用 ArrayList 中引用原来封装的数组对象的引用变量引用到新的数组对象。

When to use ArrayList and LinkedList in Java - javatpoint https://www.javatpoint.com/when-to-use-arraylist-and-linkedlist-in-java

When to use ArrayList and LinkedList in Java

ArrayList provides constant time for search operation, so it is better to use ArrayList if searching is more frequent operation than add and remove operation. The LinkedList provides constant time for add and remove operations. So it is better to use LinkedList for manipulation.

ArrayList has O(1) time complexity to access elements via the get and set methods.

LinkedList has O(n/2) time complexity to access the elements.

LinkedLinked class implements Deque interface also, so you can get the functionality of double ended queue in LinkedList. The ArrayList class doesn't implement Deque interface.

In sort, ArrayList is better to access data wherease LinkedList is better to manipulate data. Both classes implements List interface.

package com.mycom;

import java.util.ArrayList;
import java.util.List;

public class ArrayListExample {
    public static void main(String[] args) {
        //Array is better to store and view data
        List<String> list = new ArrayList<>();
        list.add("ankit");
        list.add("peter");
        list.add("mayank");

        System.out.println("Traversing ArrayList...");
        for (String s : list) {
            System.out.println(s);
        }
    }
}

　　

Traversing ArrayList...
ankit
peter
mayank

package com.mycom;

import java.util.LinkedList;
import java.util.List;

public class LinkedListExample {
    public static void main(String[] args) {
        //Linkedlist is better to manipulate data
        List<String> list = new LinkedList<>();
        list.add("ankit");
        list.add("peter");
        list.add("mayank");
        System.out.println("After adding:" + list);
        list.remove("peter");
        System.out.println("After removing:" + list);

        /**
         * Replaces the element at the specified position in this list with the
         * specified element.
         *
         * @param index index of the element to replace
         * @param element element to be stored at the specified position
         * @return the element previously at the specified position
         * @throws IndexOutOfBoundsException {@inheritDoc}
         */
        list.set(1, "vivek");
        System.out.println("After changing:" + list);
    }
}

　　

After adding:[ankit, peter, mayank]
After removing:[ankit, mayank]
After changing:[ankit, vivek]

Java ArrayList和Vector、LinkedList与ArrayList、数组(Array)和列表集合(ArrayList)的区别 - 随行-LV - 博客园 https://www.cnblogs.com/Liang-Haishan216/p/6186920.html

ArrayList vs LinkedList in Java - GeeksforGeeks https://www.geeksforgeeks.org/arraylist-vs-linkedlist-java/

ArrayList vs LinkedList in Java

Two popular lists in Java are:

1. ArrayList:-Implemented with the concept of dynamic array.

ArrayList<Type> arrL = new ArrayList<Type>();

Here Type is the data type of elements in ArrayList
to be created

2. LinkedList:-Implemented with the concept of doubly linked list.

LinkedList<Type> linkL = new LinkedList<Type>();

Here Type is the data type of elements in LinkedList
to be created

Comparision between ArrayListand LinkedList:-

1. Insertions are easy and fast in LinkedList as compared to ArrayList because there is no
   risk of resizing array and copying content to new array if array gets full which makes
   adding into ArrayList of O(n) in worst case, while adding is O(1) operation in LinkedList
   in Java. ArrayList also needs to be update its index if you insert something anywhere except
   at the end of array.
2. Removal also better in LinkedList than ArrayList due to same reasons as insertion.
3. LinkedList has more memory overhead than ArrayList because in ArrayList each index only
   holds actual object (data) but in case of LinkedList each node holds both data and address
   of next and previous node.
4. Both LinkedList and ArrayList require O(n) time to find if an element is present or not. However we can do Binary Search on ArrayList if it is sorted and therefore can search in O(Log n) time.

// Java program to demonstrate difference between ArrayList and

// LinkedList.

package com.mycom;

import java.util.ArrayList;
import java.util.LinkedList;

public class ArrayListLinkedListExample {
    public static void main(String[] args) {
        ArrayList<String> arrlistobj = new ArrayList<>();
        arrlistobj.add("0.Practice");
        arrlistobj.add("1.Quiz");
        arrlistobj.add("2.Code");
        arrlistobj.remove(1);//Remove value at index 2
        System.out.println("ArrayList object output:" + arrlistobj);
        // Checking if an elemant is present.
        if (arrlistobj.contains("2.Code"))
            System.out.println("Found");
        else
            System.out.println("Not found");

        LinkedList llobj = new LinkedList();
        llobj.add("0.Practice");
        llobj.add("1.Quiz");
        llobj.add("2.Code");
        llobj.remove("1.Quiz");
        System.out.println("LinkedList object output:" + llobj);
        //Checking if an element is present
        if (llobj.contains("2.Code"))
            System.out.println("Found");
        else
            System.out.println("Not found");
    }
}