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

迭代器遍历列表 构造方法 constructor ArrayList Vector LinkedList Array List 时间复杂度的更多相关文章

  1. ArrayList Vector LinkedList(一)

    ArrayList Vector LinkedList 区别与用法 ArrayList 和Vector是采用数组方式存储数据,此数组元素数大于实际存储的数据以便增加和插入元素,都允许直接序号索引元素, ...

  2. 请说出ArrayList,Vector, LinkedList的存储性能和特性

    请说出ArrayList,Vector, LinkedList的存储性能和特性 解答:ArrayList和Vector都是使用数组方式存储数据,此数组元素数大于实际存储的数据以便增加和插入元素,它们都 ...

  3. paip.提升性能---list,arraylist,vector,linkedlist,map的选用..

    paip.提升性能---list,arraylist,vector,linkedlist,map的选用.. arraylist,vector基本一样,但是,vector线程安全的. 作者Attilax ...

  4. Arraylist Vector Linkedlist区别和用法 (转)

    ArrayList 和Vector是采用数组方式存储数据,此数组元素数大于实际存储的数据以便增加和插入元素,都允许直接序号索引元素,但是插入数据要设计到数组元素移动等内存操作,所以索引数据快插入数据慢 ...

  5. java集合(ArrayList,Vector,LinkedList,HashSet,TreeSet的功能详解)

    说起集合,我们会潜意识里想到另外一个与之相近的名词——数组,OK!两者确实有相似之处,但也正是这点才是我们应该注意的地方,下面简单列出了两者的区别(具体功能的不同学习这篇文章后就会明白了): 数组 长 ...

  6. Java中ArrayList,Vector,LinkedList,HashMap,HashTable,HashSet对比及总结

    1.所有的集合的父类都是Collection的接口 2.Set List Map 区别 A  在Set里面:无法添加元素的顺序,所以Set里面的元素不能重复 B  在List中:有索引号,类似于数组, ...

  7. ArrayList Vector LinkedList 区别与用法

    转载自: http://www.cnblogs.com/mgod/archive/2007/08/05/844011.html 最近用到了,所以依然是转载 ArrayList 和Vector是采用数组 ...

  8. Java ArrayList Vector LinkedList Stack Hashtable等的差别与用法(转)

    ArrayList 和Vector是采取数组体式格式存储数据,此数组元素数大于实际存储的数据以便增长和插入元素,都容许直接序号索引元素,然则插入数据要设计到数组元素移动等内存操纵,所以索引数据快插入数 ...

  9. 【转】ARRAYLIST VECTOR LINKEDLIST 区别与用法

    转自:http://www.cnblogs.com/mgod/archive/2007/08/05/844011.html ArrayList 和Vector是采用数组方式存储数据,此数组元素数大于实 ...

随机推荐

  1. uboot第二阶段分析1

    一. uboot第二阶段初识 1.1. uboot第二阶段应该做什么 a. 概括来讲uboot第一阶段主要就是初始化了SoC内部的一些部件(譬如看门狗.时钟),然后初始化DDR并且完成重定位. b.  ...

  2. GUI自动化测试中优化测试用例思维方法

    1.测试脚本与数据解耦(数据驱动) 让操作相同但是数据不同的测试可以通过同一 套自动化测试脚本来实现,只是在每次测试执行时提供不同的测试输入数据. 2.页面对象模型(POM) 以页面为单位来封装页面上 ...

  3. 思维体操: HDU1287破译密码

    破译密码 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submi ...

  4. liunx驱动----信号量的实现

    使用信号量必须包含  <asm/semaphore.h>  头文件.其中相关结构体  struct semaphore 可以通过以下几种方式来声明或者初始化. 1.void sema_in ...

  5. Hangfire

    参考 开源分布式Job系统,调度与业务分离-如何创建一个计划HttpJob任务

  6. python的java胶水(jpype1)

    1.直接使用pip安装jpype1 命令 pip install jpype1 但是,很不幸,提示报错,缺少VC++组件. 2.使用其他方法安装 在  https://www.lfd.uci.edu/ ...

  7. AtCoder Beginner Contest 089 D - Practical Skill Test

    Problem Statement We have a grid with H rows and W columns. The square at the i-th row and the j-th ...

  8. case_match

    //箭头符号 => 隔开了模式和表达式.//选择器 match {备选项}.//只要发现有一个匹配的case,剩下的case不会继续匹配. //object case_test {//// de ...

  9. Redis 启动警告解决

    Redis 启动警告解决[转] [root@centos224]# service redisd start 21985:M 24 Nov 04:07:20.376 * Increased maxim ...

  10. QQ群文件未通过安全检查,禁止下载该文件

    直接用手机收藏群文件,然后用电脑登上qq去收藏里面下载就ok了