public static void main(String[] args)
{
    //PSVM，main函数
}
public void main()
{
    //普通main函数，不是入口函数
}

byte a = (byte) -129;
System.out.println(a);//127
byte b = (byte) 128;
System.out.println(b);//-128

A obj = new A();

public class Test{
    private int id;

    public Test(int id){
        //在这个构造函数里，形参优先级更高
        this.id = id;
    }

    public int getId(){
        return id;
    }
}

this.add(1,2);//调用本类的add方法，this可忽略

this(5);//调用本类的一个形参的构造函数

public interface Animal{
    public void eat();
    public void move();
}

Human obj1 = new Man();//OK, Man extends Human
Man obj2 = (Man) obj1;//OK, because obj1 is born from Man class

public class Man extends Human{
    public void eat(){
        System.out.println("I can eat more");
    }
    public void plough() { }

    public static void main(String[] a){
        Man obj1 = new  Man();
        obj1.eat();//call Man.eat()
        Human obj2 = (Human) obj1;
        obj2.eat();//call Man.eat()
        Man obj3 = (Man) obj2;
        obj3.eat();//call Man.eat()
    }
}

class StaticBlock
{
    static
    {
        System.out.println("static 块");
    }
    {
        System.out.println("匿名块");
    }
    public StaticBlock()
    {
        System.out.println("构造函数");
    }
    {
        System.out.println("匿名块");
    }
}

class FinalObject
{
    int a = 10;
}
public class FinalObjectTest{
    public static void main(String[] args){
        final FinalObject obj1 = new FinalObject();
        System.out.println(obj1.a);
        obj1.a = 20;
        System.out.println(obj1.a);//正确，可以修改内部值

        obj1 = new FinalObject();//报错，不能修改指针
    }
}

Long l1 = -128L;
Long l2 = -128L;
System.out.println(String.valueOf(l1==l2));//true

Float f1 = 0.5f;
Float f2 = 0.5f;
System.out.println(String.valueOf(f1 == f2));//false

Double d1 = 0.5;
Double d2 = 0.5;
System.out.println(String.valueOf(d1 == d2));//false

Integer a = 10;
String b = "abc";

Integer c = new Integer(10);
String d = new String("abc");

int i1 = 10;
Integer i2 = 10;//自动装箱
System.out.println(i1 == i2);//true
//自动拆箱 基本类型和包装类进行比较，包装类自动拆箱

Integer i3 = new Integer(10);
System.out.println(i1 == i3);//true
//自动拆箱 基本类型和包装类进行比较，包装类自动拆箱

System.out.println(i2 == i3);//false
//两个对象比较，比较其地址
//i2是常量，放在栈内存常量池中，i3是new出对象，放在堆内存中

Integer i4 = new Integer(5);
Integer i5 = new Integer(5);
System.out.println(i1 == (i4+i5));//true
System.out.println(i2 == (i4+i5));//true
System.out.println(i3 == (i4+i5));//true
//i4+i5操作将会使得i4,i5自动拆箱为基本类型并运算得到10
//基础类型10和对象相比，将会使对象自动拆箱，做基本类型比较

Integer i6 = i4 + i5;//+操作使得i4,i5自动拆箱，得到10，因此i6 == i2
System.out.println(i1 == i6);//true
System.out.println(i2 == i6);//true
System.out.println(i3 == i6);//false

String s0 = "abcdef";
String s1 = "abc";
String s2 = "abc";
String s3 = new String("abc");
String s4 = new String("abc");
System.out.println(s1 == s2);//true常量池
System.out.println(s1 == s3);//false一个栈内存，一个堆内存
System.out.println(s3 == s4);//false两个都是堆内存

String s5 = s1 + "def";//设计到变量，编译器不优化
String s6 = "abc" + "def";//都是常量，编译器会自动优化成abcdef
String s7 = "abc" + new String("def");//设计到new对象，编译器不优化
System.out.println(s5 == s6);//false
System.out.println(s6 == s7);//false
System.out.println(s0 == s6);//true

String s8 = s3 + "def";//涉及到new对象，编译器不优化
String s9 = s4 + "def";//设计到new对象，编译器不优化
String s10 = s3 + new String("def");//涉及到new对象，编译器不优化
System.out.println(s8 == s9);//false
System.out.println(s8 == s10);//false
System.out.println(s9 == s10);//false

String a = new String("abc");
String b = a;
System.out.println(b);//abc
a = "def";
System.out.println(b);//abc

public static void change(String b)
{
    b = "def";
}
a = new String("abc");
change(a);
System.out.println(a);//abc

String a = "abc";
a = a + "def";//String不可修改，需新申请空间，效率差

public static void changeValue(int a)
{
    a = 10;
}
public static void changeValue(String s1)
{
    s1 = "def";
}
public static void changeValue(StringBuffer s1)
{
    s1.append("def");
}

public static void main(String[] args)
{
    int a = 5;
    String b = "abc";
    StringBuffer c = new StringBuffer("abc");
    changeValue(a);
    changeValue(b);
    changeValue(c);
    System.out.println(a);//5
    System.out.println(b);//abc
    System.out.println(c);//abcdef
}

package cn.edu.pku;
public class PackageExample
{
}

package cn.edu.pku;
import cn.edu.pku.PackageExample;
//或import cn.edu.pku.*
//但不能是import cn.*
//若PackageExample和当前类在同一个目录，可省略import

public class PackageExampleTest{
    public static void main(String[] args){
        PackageExample obj = new PackageExample();
        //此处可用类的短名称来引用
    }
}

javac c:\temp\cn\com\test\Man.java

class A { }//default class
public class B{ }//public class

BigInteger b1 = new BigInteger("123456789");
BigInteger b2 = new BigInteger("987654321");
System.out.println(b2.add(b1));//加法操作
System.out.println(b2.subtract(b1));//减法操作
System.out.println(b2.multiply(b1));//乘法操作
System.out.println(b2.divide(b1));//除法操作
System.out.println(b2.max(b1));//求出最大数
System.out.println(b2.min(b1));//求出最小数
BigInteger result[] = b2.divideAndRemainder(b1);//求出余数的除法操作
System.out.println("商是：" + result[0] + "；余数是：" + result[1]);//求出余数的除法操作
System.out.println(b1.equals(b2));//是否等价
int flag = b1.compareTo(b2);
if(flag == -1)
    System.out.println("比较操作：b1<b2");
else if(flag == 0)
    System.out.println("比较操作：b1==b2");
else
    System.out.println("比较操作：b1>b2");

System.out.println(new BigDecimal("2.3"));
System.out.println(new BigDecimal(2.3));//2.29999999999999

BigDecimal num1 = new BigDecimal("10");
BigDecimal num2 = new BigDecimal("3");
//需要指定位数，防止无限循环，或者包含在try-catch中
BigDecimal num3 = num1.divide(num2, 3, BigDecimal.ROUND_HALF_UP);
System.out.println(num3);

//第一种，采用Random类随机生成
Random rd = new Random();
System.out.println(rd.nextInt());
System.out.println(rd.nextInt(100));//0-100的随机数
System.out.println(rd.nextLong());
System.out.println(rd.nextDouble());

//第二种，生成一个范围内的随机数 例如0-10之间的随机数
System.out.println(Math.round(Math.random()*10));

//JDK 8 新增方法
rd.ints();//返回无限个int类型范围内的数据
int[] arr = rd.ints(10).toArray();//生成10个int范围类的个数
for(int i = 0;i < arr.length; i++){
    System.out.println(arr[i]);
}

arr = rd.ints(5, 10, 100).toArray();//5个10-100的随机数
for(int i = 0; i < arr.length; i++){
    System.out.println(arr[i]);
}

arr = rd.ints(10).limit(5).toArray();
for(int i = 0;i < arr.length; i++){
    System.out.println(arr[i]);
}

String a = "123;456,789,123 ";
System.out.println(a.charAt(0));//返回第0个元素
System.out.println(a.indexOf(";"));//返回第一个;的位置
System.out.println(a.concat(";000"));//连接一个新字符串并返回，a不变
System.out.println(a.contains("000"));//判断a是否包含000
System.out.println(a.endWith("000"));//判断a是否以000结尾
System.out.println(a.equals("000"));//判断是否等于000
System.out.println(a.equalsIgnoreCase("000"));//判断在忽略大小写情况下是否等于000
System.out.println(a.length());//返回a长度
System.out.println(a.trim());//返回a去除前后空格后的字符串，a不变
String[] b = a.split(";");//将a字符串按照;分割成数组
for(int i = 0; i < b.length; i++){
    System.out.println(b[i]);
}

System.out.println(a.substring(2, 5));//截取a的第2个到第5个字符 a不变
System.out.println(a.replace("1", "a"));
System.out.println(a.replaceAll("1", "a");//replaceAll第一个参数是正则表达式

String s1 = "123456789";
String s2 = s1.replace("?", "a");
String s3 = s1.replaceAll("[?]", "a");
//这里的[?]才表示字符问号，这样才能正常替换。不然在正则中会有特殊的意义就会报异常

Calendar calendar = Calendar.getInstance();

public void test1(){
    //获取年
    int year = calendar.get(Calendar.YEAR);
    //获取月
    int month = calendar.get(Calendar.MONTH) + 1;
    //获取日
    int day = calendar.get(Calendar.DAY_OF_MONTH);
    //获取时
    int hour = calendar.get(Calendar.HOUR);
    //获取分
    int minute = calendar.get(Calendar.MINUTE);
    //获取秒
    int second = calendar.get(Calendar.SECOND);
    //星期，从星期日算起
    int weekday = calendar.get(Calendar.DAY_OF_WEEK);
}

//一年后的今天
public void test2(){
    calendar.add(Calendar.YEAR, 1);
    
    //获取年
    int year = calendar.get(Calendar.YEAR);
    //获取月
    int month = calendar.get(Calendar.MONTH) + 1;
    //获取日
    int day = calendar.get(Calendar.DAY_OF_MONTH);
}

//获取任意一个月的最后一天
public void test3(){
    //假设求6月的最后一天
    int currentMonth = 6;
    //先求出7月份的第一天
    calendar.set(calendar.get(Calendar.YEAR), currentMonth, 1);
    calendar.add(Calenadr.DATA, -1);

    //获取日
    int day = calendar.get(Calendar.DAY_OF_MONTH);
}

//设置日期
public void test4(){
    calendar.set(Calendar.YEAR, 2000);
    System.out.println("现在是" + calendar.get(Calendar.YEAR) + "年");

    calendar.set(2018, 1, 2);
    //获取年
    int year = calendar.get(Calendar.YEAR);
    //获取月
    int month = calendar.get(Calendar.MONTH) + 1;
    //获取日
    int day = calendar.get(Calendar.DAY_OF_MONTH);
}

public void test5(){
    calendar.set(2018, 7, 8);
    calendar.add(Calendar.DAY_OF_MONTH, -8);
    //获取年
    int year = calendar.get(Calendar.YEAR);
    //获取月
    int month = calendar.get(Calendar.MONTH) + 1;
    //获取日
    int day = calendar.get(Calendar.DAY_OF_MONTH);

    System.out.println("2018.7.8，用add减少8天，现在是" + year + "." + month + "." + day);
    //2018.7.31

    calendar.set(2018, 7, 8);
    calendar.roll(Calendar.DAY_OF_MONTH, -8);

    //获取年
    int year = calendar.get(Calendar.YEAR);
    //获取月
    int month = calendar.get(Calendar.MONTH) + 1;
    //获取日
    int day = calendar.get(Calendar.DAY_OF_MONTH);
    System.out.println("2018.7.8，用roll减少8天，现在是" + year + "." + month + "." + day);
    //2018.8.31只改变天数，不改变月份
}

//当前时间
LocalDate today = LocalDate.now();
//根据指定时间创建LocalDate
LocalDate firstDay_2014 = LocalDate.of(2014, Month.JANUARY, 1);
//给定错误时间参数，将报异常java.time.DateTimeException
//LocalDate firstDay_2014 = LocalDate.of(2014, Month.FEBRUARY, 29);
//可更改时区
LocalDate todayBeijing = LocalDate.now(ZoneId.of("Asia/Shanghai"));
//从纪元日01/01/1970开始365天
LocalDate dateFromBase = LocalDate.ofEpochDay(365);
//2014年的第100天
LocalDate hundredDay2014 = LocalDate.ofYearDay(2014, 100);

//当前时间 时分秒 纳秒
LocalTime time = LocalTime.now();
//根据时分秒
LocalTime specificTime = LocalTime.of(12, 20, 25, 40);
//错误的时间参数 将报DateTimeException
//LocalTime invalidTime = LocalTime.of(25,20);
//上海时间
LocalTime timeSH = LocalTime.mow(ZoneId.of("Asia/Shanghai"));
//一天当中第几秒
LocalTime specificSecondTime = LocalTime.ofSecondOfDay(10000);

//当前时间戳
Instant timestamp = Instant.now();
//从毫秒数来创建时间戳
Instant specificTime = Instant.ofEpochMilli(timestamp.toEpochMilli());

Date date = Date.from(timestamp);

LocalDate today = LocalDate.now();
//判断是否是闰年
System.out.println("Year " + today.getYear() + "is Leap Year" + today.isLeapYear());

//今天和01/01/2015比较
System.out.println("Today is before 01/01/2015" + today.isBefore(LocalDate.of(2015,1,1)));
//当前时分秒
System.out.println("Current Time =" + today.atTime(LocalTime.now()));

//加减时间
System.out.println("10 days after today will be " + today.plusDays(10));
System.out.println("3 weeks after today will be " + today.plusWeeks(3));
System.out.println("20 months after today will be " + today.plusMonths(20));
System.out.println("10 days after today will be " + today.minusDays(10));
System.out.println("3 weeks after today will be " + today.minusWeeks(3));
System.out.println("3 weeks after today will be " + today.minusMonths(20));

//调整时间
System.out.println("First date of this month = " + today.with(TemporalAdjusters.firstDayOfMonth()));
LocalDate lastDayOfYear = today.with(TemporalAdjusters.lastDayOfYear());
System.out.println("Last date of this year = " + lastDayOfYear);

//时间段计算
Period period = today.until(lastDayOfYear);
System.out.println("Period Format = " + period);
System.out.println("Months remaining in the year = " + period.getMonths());

DecimalFormat df1,df2;
//整数部分为0，#认为整数不存在，可不写；0认为没有，但至少写一位，写0
df1 = new DecimalFormat("#.00");
df2 = new DecimalFormat("0.00");

System.out.println(df1.format(0.1));//.10
System.out.println(df2.format(0.1));//0.10

df1 = new DecimalFormat("0.00");
df2 = new DecimalFormat("0.##");

System.out.println(df1.format(0.1));//0.10
System.out.println(df2.format(0.1));//0.1

df1 = new DecimalFormat("0.00");
df2 = new DecimalFormat("#.00");

System.out.println(df1.format(2));//2.00
System.out.println(df2.format(2));//2.00

System.out.println(df1.format(20));//20.00
System.out.println(df2.format(20));//20.00

System.out.println(df1.format(200));//200.00
System.out.println(df2.format(200));//200.00

String message = "{0}{1}{2}{3}{4}{5}{6}{7}{8}{9}{10}{11}{12}{13}{14}{15}{16}";
object[] array = new Object[]{"A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q"};
String value = MessageFormat.format(message, array);
System.out.println(value);
message = "oh, {0,number,#.##} is a good number";
array = new Object[]{new Double(3.1415)};
value = MessageFormat.format(message, array);

String strDate = "2008-10-19 10:11:30.345";
//准备第一个模板，从字符串中提取出日期数字
String pat1 = "yyyy-MM-dd HH:mm:ss.SSS";
//准备第二个模板，将提取后的日期数字变为指定的格式
String pat2 = "yyyy年MM月dd日 HH时mm分ss秒SSS毫秒";
SimpleDateFormat sdf1 = new SimpleDateFormat(pat1); 
SimpleDateFormat sdf2 = new SimpleDateFormat(pat2);
Date d = null;
try{
    d = sdf1.parse(strDate);//将给定的字符串中的日期提取出来
}catch(Exception e){//如果提供的字符串格式有错误，则进行异常处理
    e.printStackTrace();//打印异常信息
}
System.out.println(sdf2.format(d));//将日期变为新的格式

//将字符串转化为时间
String dateStr = "2020年1月1日";
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日");
LocalDate date = LocalDate.parse(dateStr, formatter);
System.out.println(date.getYear() + "-" + date.getMonthValue() + "-" + date.getDayOfMonth());

//将日期转换为字符串输出
LocalDateTime now = LocalDateTime.now();
DateTimeFormatter format = DateTimeFormatter.ofPattern("yyyy年MM月dd日 hh:mm:ss");
String nowStr = now.format(format);
System.out.println(nowStr);

try
{
    int a = 5/2;
    System.out.println(a);
}
catch(Exception ex)
{
    ex.printStackTrace();
}
finally
{
    System.out.println("1 over");
}


try
{
    int a = 5/0;
    System.out.println(a);
}
catch(Exception ex)
{
    ex.printStackTrace();
}
finally
{
    System.out.println("2 over");
}

try
{
    int a = 5/0;
    System.out.println(a);
}
catch(Exception ex)
{
    ex.printStackTrace();
    int a = 5/0;
}
finally
{
    System.out.println("3 over");
}

public class ThrowsDemo
{
    public static void main(String [] args)
    {
        try
        {
            int result = new Test().divide(3,1);
            System.out.println("1 result:" + result);
        }
        catch(ArithmeticException ex)
        {
            ex.printStackTrace();
        }
        int result = new Test().divide(3,0);
        System.out.println("2 result:" + result);
    }
}
class Test
{
    //ArithmeticException is a RuntimeException, not checked exception
    public int divide(int x, int y) throws ArithmeticException
    {
        int result = x/y;
        return x/y;
    }
}

public class Father{
    public void f1() throws ArithmeticException
    {

    }
}

public class Son extends Father{
    public void f1() throws Exception//错误
}

public class MyException extends Exception{
    private String returnCode;//异常对应的返回码
    private String returnMsg;//异常对应的描述信息

    public MyException(){
        super();
    }

    public MyException(String returnMsg){
        super(returnMsg);
        this.returnMsg = returnMsg;
    }

        public MyException(String returnCode, String returnMsg){
        super(returnMsg);
        this.returnCode = returnCode;
        this.returnMsg = returnMsg;
    }

    public String getReturnCode(){
        return returnCode;
    }

    public String getReturnMsg(){
        return returnMsg;
    }
}

public class MyExceptionTest {
    public static void testException() throws MyException {
        throw new MyException("10001", "The reason of myException");
    }

    public static void main(String[] args) {
        //MyExceptionTest.testException();注释1 要报错需注释掉下方代码
        try {
            MyExceptionTest.testException();
        } catch (MyException e) {
            e.printStackTrace();
            System.out.println("returnCode:" + e.getReturnCode());
            System.out.println("returnCode:" + e.getReturnMsg());
        }
    }
}

public class DivideByMinusException extends Exception {
    int divisor;
    public DivideByMinusException(String msg, int divisor)
    {
        super(msg);
        this.divisor = divisor;
    }
    public int getDevisor()
    {
        return this.getDevisor();
    }
}

public class Student {
    public int divide(int x, int y)
    {
        return x/y;
    }
    public static void main(String[] args) throws DivideByMinusException {
        Student newton = new Student();
        //newton.divide2(5,0);
        newton.divide5(5,-2);
    }

    public int divide2(int x,int y)
    {
        int result;
        try
        {
            result = x/y;
            System.out.println("result is " + result);
        }
        catch(ArithmeticException ex)
        {
            System.out.println(ex.getMessage());
            return 0;
        }
        catch(Exception ex)
        {
            ex.printStackTrace();
            return 0;
        }
    }

    public int divide3(int x,int y) throws ArithmeticException//unchecked exception
    {
        return x/y;
    }

    public int divide4(int x, int y)
    {
//        try
//        {
//            return divide3(x,y);
//        }
//        catch(ArithmeticException ex)
//        {
//            ex.printStackTrace();
//            return 0;
//        }
        return divide3(x,y);//尽管divide3报告异常，但divide4无需处理。
        //若调用divide5(x,y);就需要做try-catch处理。
    }

    public int divide5(int x,int y) throws DivideByMinusException
    {
        try
        {
            if(y < 0)
            {
                throw new DivideByMinusException("The divisor is negative", y);
            }
            return divide3(x,y);
        }
        catch(ArithmeticException ex)
        {
            ex.printStackTrace();
            return 0;
        }
    }
}

int a[];//还没有new操作，实际上是null，也不知道内存位置
int[] b;
int[] c = new int[2];//c有2个元素，都是0
c[0] = 1, c[1] = 2;//初始化

int d[] = new int[]{1,2,3};//同时定义和初始化
int d1[] = {1,2,3};//同时定义和初始化

//声明变量时没有分配内存，不需要指定大小，以下是错误的
//int a[2];
//int[2] b;
//int[2] c = new int[2];
//int d[2] = new int[2];

int[] a = new int[5];//a[0]~a[4],a.length是5

//需控制索引位置
for(int i = 0; i < d.length; i++)
{
    System.out.println(d[i]);
}

//无需控制索引位置
for(int e : d)
{
    System.out.println(e);
}

//规则数组
int a[][] = new int[2][3];
//不规则数组
int b[][];
b = new int[3][];
b[0] = new int[3];
b[1] = new int[4];
b[2] = new int[5];

int k = 0;
for(int i = 0; i < a.length; i++)
{
    for(int j = 0; j < a[i].length; j++)
    {
        a[i][j] = ++k;
    }
}

for(int[] items : a)
{
    for(int item : items)
    {
        System.out.println(item + ", ");
    }
    System.out.println();
}

import java.util.ArrayList;
//Vector几乎和ArrayList一样，除了Vector本身是同步的

public class ArrayListTest{
    public static void main(String[] a){
        ArrayList<Integer> al = new ArrayList<Integer>();//ArrayList<Integer> al 是泛型表示，意思是al这个数据结构里只能容纳Integer的对象，其它对象无法放入
        al.add(1);//ArrayList只能装对象，当add(1)时，会自动将普通int变量1自动装箱为Integer(1)的对象，然后放入ArrayList容器中
        al.add(2);
        al.add(3);
        al.add(4);
        al.add(new Integer(6));

        System.out.println(al.get(3));
        al.remove(3);//删除第4个元素，后面元素往前挪
        al.add(3, 0);//将0插入到第3个元素，后面元素往后挪

        //遍历方法
        ArrayList<Integer> as = new ArrayList<Integer>(100000);
        for(int i = 0; i < 100000; i++)
        {
            as.add(i);
        }
        traverseByIterator(as);
        traverseByIndex(as);
        traverseByFor(as);
    }
    //迭代器遍历
    public static void traverseByIterator(ArrayList<Integer> al)
    {
        long startTime = System.namoTime();
        Iterator<Integer> iter1 = al.iterator();
        while(iter1.hasNext()){
            iter1.next();
        }
        long endTime = System.nanoTime();
        long duration = endTime - startTime;
        System.out.println(duration + "纳秒");
    }
    //随机索引值遍历
    public static void traverseByIndex(ArrayList<Integer> al)
    {
        long startTime = System.namoTime();
        for(int i = 0; i< al.size(); i++)
        {
            al.get(i);
        }
        long endTime = System.nanoTime();
        long duration = endTime - startTime;
        System.out.println(duration + "纳秒");
    }
    //for循环遍历
    public static void traverseByFor(ArrayList<Integer> al)
    {
        long startTime = System.namoTime();
        for(Integer item : al)
        {
            ;
        }
        long endTime = System.namoTime();
        long duration = endTime - startTime;
        System.out.println(duration + "纳秒");
    }
}

import java.util.ArrayList;


public class LinkedListTest{
    public static void main(String[] a){
        LinkedList<Integer> ll = new LinkedList<Integer>();
        ll.add(1);
        ll.add(2);
        ll.add(3);
        ll.add(4);
        System.out.println(ll.size());
        ll.addFirst(0);//在头部增加0
        ll.add(3,5);//将5插入到第四个元素，四及后续元素往后挪
        ll.remove(3);//将第四个元素删除

        LinkedList<Integer> list = new LinkedList<Integer>();
        for(int i = 0; i < 100000; i++)
        {
            list.add(i);
        }
        traverseByIterator(list);
        traverseByIndex(list);
        traverseByFor(list);       
    }
    //迭代器遍历
    public static void traverseByIterator(LinkedList<Integer> list)
    {
        long startTime = System.namoTime();
        Iterator<Integer> iter1 = list.iterator();
        while(iter1.hasNext()){
            iter1.next();
        }
        long endTime = System.nanoTime();
        long duration = endTime - startTime;
        System.out.println(duration + "纳秒");
    }
    //随机索引值遍历
    public static void traverseByIndex(LinkedList<Integer> list)
    {
        long startTime = System.namoTime();
        for(int i = 0; i< list.size(); i++)
        {
            list.get(i);
        }
        long endTime = System.nanoTime();
        long duration = endTime - startTime;
        System.out.println(duration + "纳秒");
    }
    //for循环遍历
    public static void traverseByFor(LinkedList<Integer> list)
    {
        long startTime = System.namoTime();
        for(Integer item : list)
        {
            ;
        }
        long endTime = System.namoTime();
        long duration = endTime - startTime;
        System.out.println(duration + "纳秒");
    }
}

import java.util.ArrayList;

public class ListCompareTest {
    public static void main(String[] args) {
        int times = 10 * 1000;

        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        LinkedList<Integer> linkedList = new LinkedList<Integer>();

        //ArrayList add
        long startTime = System.nanoTime();

        for(int i = 0; i < times; i++) {
            arrayList.add(0, i);//add到头部
        }
        long endTime = System.namoTime();
        long duration = endTime - startTime;
        System.out.println(duration + "纳秒");

        //LinkedList add
        startTime = System.nanoTime();

        for(int i = 0; i < times; i++) {
            linkedList.add(0, i);
        }
        endTime = System.namoTime();
        duration = endTime - startTime;
        System.out.println(duration + "纳秒");

        //ArrayList get
        startTime = System.nanoTime();

        for(int i = 0; i < times; i++) {
            arrayList.get(i);
        }
        endTime = System.namoTime();
        duration = endTime - startTime;
        System.out.println(duration + "纳秒");

        //LinkedList get
        startTime = System.nanoTime();

        for(int i = 0; i < times; i++) {
            linkedList.get(i);
        }
        endTime = System.namoTime();
        duration = endTime - startTime;
        System.out.println(duration + "纳秒");

        //ArrayList remove
        startTime = System.nanoTime();

        for(int i = 0; i < times; i++) {
            arrayList.remove(0);
        }
        endTime = System.namoTime();
        duration = endTime - startTime;
        System.out.println(duration + "纳秒");

        //LinkedList remove
        startTime = System.nanoTime();

        for(int i = 0; i < times; i++) {
            linkedList.remove(0);
        }
        endTime = System.namoTime();
        duration = endTime - startTime;
        System.out.println(duration + "纳秒");
    }
}

import java.util.ArrayList;

public class VectorTest {
    public static void main(String[] args) {
        Vector<Integer> v = new Vector<Integer>();
        v.add(1);
        v.add(2);
        v.add(3);
        v.remove(2);
        v.add(1, 5);
        System.out.println(v.size());

        //遍历方法

        Vector<Integer> v2 = new Vector<Integer>(100000);
        for(int i = 0; i < 100000; i++) {
            v2.add(i);
        }
        traverseByIterator(v2);
        traverseByIndex(v2);
        traverseByFor(v2);    
        traverseByEnumeration(v2);  
    }

    //迭代器遍历
    public static void traverseByIterator(Vector<Integer> v)
    {
        long startTime = System.namoTime();
        Iterator<Integer> iter1 = v.iterator();
        while(iter1.hasNext()){
            iter1.next();
        }
        long endTime = System.nanoTime();
        long duration = endTime - startTime;
        System.out.println(duration + "纳秒");
    }
    //随机索引值遍历
    public static void traverseByIndex(Vector<Integer> v)
    {
        long startTime = System.namoTime();
        for(int i = 0; i< v.size(); i++)
        {
            v.get(i);
        }
        long endTime = System.nanoTime();
        long duration = endTime - startTime;
        System.out.println(duration + "纳秒");
    }
    //for循环遍历
    public static void traverseByFor(Vector<Integer> v)
    {
        long startTime = System.namoTime();
        for(Integer item : v)
        {
            ;
        }
        long endTime = System.namoTime();
        long duration = endTime - startTime;
        System.out.println(duration + "纳秒");
    }
    //Enumeration遍历
    public static void traverseByEnumeration(Vector<Integer> v)
    {
        long startTime = System.namoTime();
        for(Enumeration<Integer> enu = v.elements(); enu.hasMoreElements();) {
            enu.nextElement();
        }
        long endTime = System.namoTime();
        long duration = endTime - startTime;
        System.out.println(duration + "纳秒");
    }
}

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;

public class HashSetTest {
	public static void main(String[] args) {
		HashSet<Integer> hs = new HashSet<Integer>();
		hs.add(null);
		hs.add(1);
		hs.add(2);
		hs.add(3);
		hs.add(40000);
		hs.add(5000000);
		hs.add(3);                      //3 重复
		hs.add(null);                   //null重复
		System.out.println(hs.size());  //6
		if(!hs.contains(6))
		{
			hs.add(6);
		}
		System.out.println(hs.size());  //7
		hs.remove(4);
		System.out.println(hs.size());  //6
		//hs.clear();
		//System.out.println(hs.size());  //0
		
		//or循环遍历
	    for(Integer item : hs)
	    {
	    	System.out.println(item);
	    }
	    
	    //测试集合交集	    
	    HashSet<String> set1 = new HashSet<String>();
	    HashSet<String> set2 = new HashSet<String>();

        set1.add("a");
        set1.add("b");
        set1.add("c");

        set2.add("c");
        set2.add("d");
        set2.add("e");

        //交集
        set1.retainAll(set2);
        System.out.println("交集是 "+set1);
        
        //测试遍历方法速度		
		HashSet<Integer> hs2 = new HashSet<Integer>();
		for(int i=0;i<100000;i++)	{
			hs2.add(i);
		}
		traverseByIterator(hs2);
		traverseByFor(hs2);		
	}
	
	public static void traverseByIterator(HashSet<Integer> hs)
	{
		long startTime = System.nanoTime();
		//迭代器遍历 
	    Iterator<Integer> iter1 = hs.iterator();  
	    while(iter1.hasNext()){  
	        iter1.next();  
	    }
		long endTime = System.nanoTime();
	    long duration = endTime - startTime;
	    System.out.println(duration + "纳秒");
	}
	public static void traverseByFor(HashSet<Integer> hs)
	{
		long startTime = System.nanoTime();
		//for循环遍历
	    for(Integer item : hs)
	    {
	    	;
	    }
		long endTime = System.nanoTime();
	    long duration = endTime - startTime;
	    System.out.println(duration + "纳秒");
	}
}

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;

public class LinkedHashSetTest {
	public static void main(String[] args) {
		LinkedHashSet<Integer> lhs = new LinkedHashSet<Integer>();
		lhs.add(null);
		lhs.add(1000);
		lhs.add(20);
		lhs.add(3);
		lhs.add(40000);
		lhs.add(5000000);
		lhs.add(3);                      //3 重复
		lhs.add(null);                   //null 重复
		System.out.println(lhs.size());  //6
		if(!lhs.contains(6))
		{
			lhs.add(6);
		}
		System.out.println(lhs.size());  //7
		lhs.remove(4);
		System.out.println(lhs.size());  //6
		//lhs.clear();
		//System.out.println(lhs.size());  //0
		
		//for循环遍历
	    for(Integer item : lhs)
	    {
	    	System.out.println(item);
	    }
		
		LinkedHashSet<Integer> lhs2 = new LinkedHashSet<Integer>();
		for(int i=0;i<100000;i++)
		{
			lhs2.add(i);
		}
		traverseByIterator(lhs2);
		traverseByFor(lhs2);
		
	}
	
	public static void traverseByIterator(LinkedHashSet<Integer> hs)
	{
		long startTime = System.nanoTime();
		//迭代器遍历
	    Iterator<Integer> iter1 = hs.iterator();  
	    while(iter1.hasNext()){  
	        iter1.next();  
	    }
		long endTime = System.nanoTime();
	    long duration = endTime - startTime;
	    System.out.println(duration + "纳秒");
	}
	public static void traverseByFor(LinkedHashSet<Integer> hs)
	{
		long startTime = System.nanoTime();
		//for循环遍历
	    for(Integer item : hs)
	    {
	    	;
	    }
		long endTime = System.nanoTime();
	    long duration = endTime - startTime;
	    System.out.println(duration + "纳秒");
	}
}

SortedSet s = Collections.synchronizedSortedSet(new TreeSet(...));

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.TreeSet;

public class TreeSetTest {
	public static void main(String[] args) {
		TreeSet<Integer> ts = new TreeSet<Integer>();
		// ts.add(null);  错误，不支持null
		ts.add(1000);
		ts.add(20);
		ts.add(3);
		ts.add(40000);
		ts.add(5000000);
		ts.add(3);                      //3 重复
		System.out.println(ts.size());  //5
		if(!ts.contains(6))
		{
			ts.add(6);
		}
		System.out.println(ts.size());  //6
		ts.remove(4);
		System.out.println(ts.size());  //5
		//lhs.clear();
		//System.out.println(lhs.size());  //0
		
		//for循环遍历
	    for(Integer item : ts)
	    {
	    	System.out.println(item);
	    }
	    
		TreeSet<Integer> ts2 = new TreeSet<Integer>();
		for(int i=0;i<100000;i++)
		{
			ts2.add(i);
		}
		traverseByIterator(ts2);
		traverseByFor(ts2);
		
	}
	
	public static void traverseByIterator(TreeSet<Integer> hs)
	{
		long startTime = System.nanoTime();
		//迭代器遍历
	    Iterator<Integer> iter1 = hs.iterator();  
	    while(iter1.hasNext()){  
	        iter1.next();  
	    }
		long endTime = System.nanoTime();
	    long duration = endTime - startTime;
	    System.out.println(duration + "纳秒");
	}
	public static void traverseByFor(TreeSet<Integer> hs)
	{
		long startTime = System.nanoTime();
		//for循环遍历
	    for(Integer item : hs)
	    {
	    	;
	    }
		long endTime = System.nanoTime();
	    long duration = endTime - startTime;
	    System.out.println(duration + "纳秒");
	}

}