在本文中，我们将为您详细介绍Java中Arrays类与Math类的相关知识，并且为您解答关于java的arrays类的疑问，此外，我们还会提供一些关于1、基本类型包装类2、System类3、Math类

在本文中，我们将为您详细介绍Java中Arrays类与Math类的相关知识，并且为您解答关于java的arrays类的疑问，此外，我们还会提供一些关于1、基本类型包装类 2、System类 3、Math类 4、Arrays类 5、大数据运算、Flex中ArrayCollection 与java中的ArrayList互转、java arrayList遍历的四种方法及Java中ArrayList类的用法、Java Arrays类方法的有用信息。

• Java中Arrays类与Math类（java的arrays类）
• 1、基本类型包装类 2、System类 3、Math类 4、Arrays类 5、大数据运算
• Flex中ArrayCollection 与java中的ArrayList互转
• java arrayList遍历的四种方法及Java中ArrayList类的用法
• Java Arrays类方法

Java中Arrays类与Math类（java的arrays类）

Arrays(数组工具类)

　　Java中已经封装好的类，提供大量静态方法供用户对数组的使用。

　　导包：import java.util.Arrays

　　1.Arrays.toString(数组)　　//返回值是一个[]括起来的字符串，将数组中的元素放入[]中

1 int[] arr=new int[]{1,2,3,4};
2         String str=Arrays.toString(arr);
3         System.out.println(str);
4 --------------------------------
5 [1,2,3,4]

　　2.Arrays.sort(数组）　　//无返回值，将数组排序，（从小到大升序）数组已经发生改变

1 int[] arr=new int[]{3,27,46,1,48};
2 //        String str=Arrays.toString(arr);
3 //        System.out.println(str);
4         Arrays.sort(arr);
5         for(int i=0;i<arr.length;i++){
6                 System.out.print(arr[i]);        
7 }
8 ===========================
9 1 3 27 46 48

Math（数学类）

　　导包：import java.lang (可省略)

　　a.Math.abs(数值)　　//返回数值的绝对值

　　b.Math.ceil(数值)　　//返回数值的向上取整

　　c.Math.floor(数值)　　//返回数组的向下取整

　　d.Math.roud(数值)　　//返回数值的四舍五入

　　e.Math.PI　　//圆周率的取值

1、基本类型包装类 2、System类 3、Math类 4、Arrays类 5、大数据运算

01基本数据类型对象包装类概述

 *A:基本数据类型对象包装类概述
   *a.基本类型包装类的产生
       在实际程序使用中，程序界面上用户输入的数据都是以字符串类型进行存储的。而程序开发中，我们需要把字符串数据，根据需求转换成指定的基本数据类型，如年龄需要转换成int类型，考试成绩需要转换成double类型等
   *b.八种基本类型对应的包装类
       char    Character
       int     Integer
       byte    Byte
       short   Short
       long    Long
       float   Float
       double  Double
       boolean Boolean

02Integer类parseInt方法

   *A:Integer类parseInt方法:
    *a:parseInt()
        int i = Integer.parseInt("12");
        System.out.println(i/2);//6
     
    *b:parseInt(String s, int radix)
        /*
          * Integer类静态方法parseInt(String s, int radix)
          * radix基数,进制
          * "110",2 含义 前面的数字是二进制的,但是方法parseInt运行结果都是十进制
          *  指定进制的字符串转换为十进制的整数
          */
         public static void function_1(){
             int i = Integer.parseInt("110", 2);
             System.out.println(i);
         }

03Integer类int转成字符串

*A:Integer类int转成字符串:
   *a:使用+与字符串拼接
        int i = 3;
          String s = i+"";
          System.out.println(s+1);//"31"
  
   *b:toString(int ,int 进制),任意进制整数转成任意进制的字符串 (了解)
          String s1 = Integer.toString(5,2);
          System.out.println(s1);

04Integer类构造方法

 *A:Integer类构造方法
    /*
     *  Integer类构造方法
     *   Integer (String s)
     *   将数字格式的字符串,传递到Integer类的构造方法中
     *   创建Integer对象,包装的是一个字符串
     *   将构造方法中的字符串,转成基本数据类型,调用方法,非静态的, intValue()
     */
    public static void function_3(){
        Integer in = new Integer("100");
        int i = in.intValue();
        System.out.println(--i);//99
    }

05Integer类其他方法

*A:Integer类其他方法

     /*
     * Integer类的3个静态方法
     * 做进制的转换
     * 十进制转成二进制  toBinarString(int)
     * 十进制转成八进制  toOctalString(int)
     * 十进制转成十六进制 toHexString(int)
     * 三个方法,返回值都是以String形式出现
     */
      a:十进制转二,八,十六进制
          public static void function_1(){
                System.out.println(Integer.toBinaryString(99));
                System.out.println(Integer.toOctalString(99));
                System.out.println(Integer.toHexString(999));
          }
      b:获取int的最大值和最小值
      /*
       *   Integer类的静态成员变量
       *   MAX_VALUE
       *   MIN_VALUE
       */
      public static void function(){
          System.out.println(Integer.MAX_VALUE);
          System.out.println(Integer.MIN_VALUE);
      }

06自动装箱和自动拆箱

*A:自动装箱与自动拆箱:

//JDK1.5新特性
//自动装箱,拆箱的 好处: 基本类型和引用类直接运算
//自动装箱:使用Integer.valueOf(整数值)返回一个封装了该整数值的Integer对象
//自动拆箱:使用Integer对象.intValue()返回Integer对象中封装的整数值
public static void function(){
    //引用类型 , 引用变量一定指向对象
    //自动装箱, 基本数据类型1, 直接变成了对象
    
    Integer in = 1; // Integer in = new Integer(1)
    //in 是引用类型,不能和基本类型运算, 自动拆箱,引用类型in,转换基本类型
    
    //in+1  ==> in.inValue()+1 = 2    
    //in = 2    自动装箱
    in = in + 1;
    
    System.out.println(in);
    
}
  

07自动装箱和自动拆箱练习题

*A:自动装箱与自动拆箱:

    Integer i = new Integer(1);
     Integer j = new Integer(1);
     System.out.println(i==j);// false 对象地址
     System.out.println(i.equals(j));// true  继承Object重写equals,比较的对象数据
     
     System.out.println("===================");
     
     Integer a = 500;//Integer integer=Integer.valueOf(500)
                     //integer=new Integer(500);
     Integer b = 500;
     System.out.println(a==b);//false
     System.out.println(a.equals(b));//true
     
     System.out.println("===================");
     
     
     //数据在byte(-128~127)范围内,JVM不会从新new对象
     Integer aa = 127; // Integer aa = new Integer(127)
     Integer bb = 127; // Integer bb = aa;
     System.out.println(aa==bb); //true
     System.out.println(aa.equals(bb));//true
   

=========================第二节课开始====================================

08System类方法currentTimeMillis

*A:System类方法currentTimeMillis():用于计算程序的执行时间

    /*
       *  获取系统当前毫秒值
       *  static long currentTimeMillis()
       *  对程序执行时间测试
       */
      public static void function(){
          long start = System.currentTimeMillis();//当前时间x-1970年1月1日零时零分零秒
          for(int i = 0 ; i < 10000; i++){
              System.out.println(i);
          }
          long end = System.currentTimeMillis();//当前时间y-1970年1月1日零时零分零秒
          System.out.println(end - start);//当前时间y-当前时间x 
      }

09System类方法exit

 *A:System类方法exit()方法
         /*
          *  退出虚拟机,所有程序全停止
          *  static void exit(0)
          */
         public static void function_1(){
             while(true){
                 System.out.println("hello");
                 System.exit(0);//该方法会在以后的finally代码块中使用(讲到再说)
             }
         }

10System类方法gc

A:System类方法gc

    public class Person {
        public void finalize(){
            System.out.println("垃圾收取了");
        }
    }

    /*
      *  JVM在内存中,收取对象的垃圾
      *  当没有更多引用指向该对象时,会自动调用垃圾回收机制回收堆中的对象
      *  同时调用回收对象所属类的finalize方法()
      *  static void gc()
      */
     public static void function_2(){
         new Person();
         new Person();
         new Person();
         new Person();
         new Person();
         new Person();
         new Person();
         new Person();
         System.gc();
     }

11System类方法getProperties

A:System类方法getProperties(了解)

 /*
  *  获取当前操作系统的属性:例如操作系统名称,
  *  static Properties getProperties() 
  */
 public static void function_3(){
     System.out.println( System.getProperties() );
 }
  

12System类方法arraycopy

 A:System类方法arraycopy：
  /*
   * System类方法,复制数组
   * arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
   * Object src, 要复制的源数组
   * int srcPos, 数组源的起始索引
   * Object dest,复制后的目标数组
   * int destPos,目标数组起始索引 
   * int length, 复制几个
   */
  public static void function_4(){
      int[] src = {11,22,33,44,55,66};
      int[] desc = {77,88,99,0};
      
      System.arraycopy(src, 1, desc, 1, 2);//将src数组的1位置开始(包含1位置)的两个元素,拷贝到desc的1,2位置上
      for(int i = 0 ;  i < desc.length ; i++){
          System.out.println(desc[i]);
      }
  }

================================第三节课开始======================================================

13Math类的方法_1

A:Math类中的方法
/*

    * static double sqrt(double d)
    * 返回参数的平方根
    */
   public static void function_4(){
       double d = Math.sqrt(-2);
       System.out.println(d);
   }
   
   /*0
    * static double pow(double a, double b)
    * a的b次方
    */
   public static void function_3(){
       double d = Math.pow(2, 3);
       System.out.println(d);
   }
   
   /*
    * static double floor(double d)
    * 返回小于或者等于参数d的最大整数
    */
   public static void function_2(){
       double d = Math.floor(1.5);
       System.out.println(d);
   }
   
   /*
    *  static double ceil(double d)
    *  返回大于或者等于参数d的最小整数
    */
   public static void function_1(){
       double d = Math.ceil(5.1);
       System.out.println(d);
   }
   
   /*
    *  static int abs(int i)
    *  获取参数的绝对值
    */
    public static void function(){
       int i = Math.abs(0);
       System.out.println(i);
    }

14Math类的方法_2

A:Math类的方法_2
/*

• static double round(doubl d)

• 获取参数的四舍五入,取整数
  */

public static void function_6(){

  double d = Math.round(5.4195);
  System.out.println(d);

}

/*

• static double random() 返回随机数 0.0-1.0之间

• 来源,也是Random类
  */

public static void function_5(){

  for(int i = 0 ; i < 10 ;i++){
      double d = Math.random();
      System.out.println(d);
  }

}

15Arrays工具类

A:Arrays工具类:

public class ArraysDemo {
    public static void main(String[] args) {
        function_2();
        int[] arr = {56,65,11,98,57,43,16,18,100,200};
        int[] newArray = test(arr);
        System.out.println(Arrays.toString(newArray));
    }
    /*
     *  定义方法,接收输入,存储的是10个人考试成绩
     *  将最后三个人的成绩,存储到新的数组中,返回新的数组
     */
    public static int[] test(int[] arr){
        //对数组排序
        Arrays.sort(arr);
        //将最后三个成绩存储到新的数组中
        int[] result = new int[3];
        //成绩数组的最后三个元素,复制到新数组中
    //    System.arraycopy(arr, 0, result, 0, 3);
        for(int i = 0 ;  i < 3 ;i++){
            result[i] = arr[i];
        }
        return result;
    }
    
    /*
     *  static String toString(数组)
     *  将数组变成字符串
     */
    public static void function_2(){
        int[] arr = {5,1,4,6,8,9,0};
        String s = Arrays.toString(arr);
        System.out.println(s);
    }
    
    /*
     *  static int binarySearch(数组, 被查找的元素)
     *  数组的二分搜索法
     *  返回元素在数组中出现的索引
     *  元素不存在, 返回的是  (-插入点-1)
     */
    public static void function_1(){
        int[] arr = {1,4,7,9,11,15,18};
        int index =  Arrays.binarySearch(arr, 10);
        System.out.println(index);
    }
    
    /*
     *  static void sort(数组)
     *  对数组升序排列
     */
    public static void function(){
        int[] arr = {5,1,4,6,8,9,0};
        Arrays.sort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

16数组复制练习

*A:数组复制练习:

    public static void main(String[] args) {
            int[] arr = {56,65,11,98,57,43,16,18,100,200};
            int[] newArray = test(arr);
            System.out.println(Arrays.toString(newArray));
        }
        /*
         *  定义方法,接收输入,存储的是10个人考试成绩
         *  将最后三个人的成绩,存储到新的数组中,返回新的数组
         */
        public static int[] test(int[] arr){
            //对数组排序
            Arrays.sort(arr);
            //将最后三个成绩存储到新的数组中
            int[] result = new int[3];
            //成绩数组的最后三个元素,复制到新数组中
            //System.arraycopy(arr, 0, result, 0, 3);
            for(int i = 0 ;  i < 3 ;i++){
                result[i] = arr[i];
            }
            return result;
        }

====================第四节课开始============================

17BigInteger类概述和构造方法

A:BigInteger类概述和构造方法
public static void main(String[] args) {

       function();
   }
/*
    * BigInteger类的构造方法
    * 传递字符串,要求数字格式,没有长度限制
    */
   public static void function(){
       BigInteger b = new BigInteger("8465846668464684562385634168451684568645684564564");
       System.out.println(b);
       BigInteger b1 = new BigInteger("5861694569514568465846668464684562385634168451684568645684564564");
       System.out.println(b1);
   }

18BigInteger类四则运算

A:BigInteger类四则运算

public static void main(String[] args) {
       function_1();
   }
/*
 * BigInteger对象的四则运算
 * 调用方法计算,计算结果也只能是BigInteger对象
 */
 public static void function_1(){
     BigInteger b1 = new BigInteger("5665464516451051581613661405146");
     BigInteger b2 = new BigInteger("965855861461465516451051581613661405146");
     
     //计算 b1+b2对象的和,调用方法 add
     BigInteger bigAdd = b1.add(b2);//965855867126930032902103163227322810292
     System.out.println(bigAdd);
     
     //计算b1-b2对象的差,调用方法subtract
     BigInteger bigSub = b1.subtract(b2);
     System.out.println(bigSub);
     
     //计算b1*b2对象的乘积,调用方法multiply
     BigInteger bigMul = b1.multiply(b2);
     System.out.println(bigMul);
     
     //计算b2/b1对象商,调用方法divied
     BigInteger bigDiv = b2.divide(b1);
     System.out.println(bigDiv);
 }

19员工案例的子类的编写

A:BigDecimal类概述

/*
 * 计算结果,未知
 * 原因: 计算机二进制中,表示浮点数不精确造成
 * 超级大型的浮点数据,提供高精度的浮点运算, BigDecimal
System.out.println(0.09 + 0.01);//0.09999999999999999
System.out.println(1.0 - 0.32);//0.6799999999999999
System.out.println(1.015 * 100);//101.49999999999999
System.out.println(1.301 / 100);//0.013009999999999999 
*/

20BigDecimal类实现加法减法乘法

A:BigDecimal类实现加法减法乘法
/*

   *  BigDecimal实现三则运算
   *  + - *
   */
  public static void function(){
      BigDecimal b1 =  new BigDecimal("0.09");
      BigDecimal b2 =  new BigDecimal("0.01");
      //计算b1+b2的和,调用方法add
      BigDecimal bigAdd = b1.add(b2);
      System.out.println(bigAdd);
      
      BigDecimal b3 = new BigDecimal("1");
      BigDecimal b4 = new BigDecimal("0.32");
      //计算b3-b2的差,调用方法subtract
      BigDecimal bigSub = b3.subtract(b4);
      System.out.println(bigSub);
      
      BigDecimal b5 = new BigDecimal("1.015");
      BigDecimal b6 = new BigDecimal("100");
      //计算b5*b6的成绩,调用方法 multiply
      BigDecimal bigMul = b5.multiply(b6);
      System.out.println(bigMul);
  }

21BigDecimal类实现除法

 A:BigDecimal类实现除法
 /*
  * BigDecimal实现除法运算
  * divide(BigDecimal divisor, int scale, int roundingMode) 
  * int scale : 保留几位小数
  * int roundingMode : 保留模式
  * 保留模式 阅读API文档
  *   static int ROUND_UP  向上+1
  *   static int ROUND_DOWN 直接舍去
  *   static int ROUND_HALF_UP  >= 0.5 向上+1
  *   static int ROUND_HALF_DOWN   > 0.5 向上+1 ,否则直接舍去
  */
 public static void function_1(){
     BigDecimal b1 = new BigDecimal("1.0301");
     BigDecimal b2 = new BigDecimal("100");
     //计算b1/b2的商,调用方法divied
     BigDecimal bigDiv = b1.divide(b2,2,BigDecimal.ROUND_HALF_UP);//0.01301
     System.out.println(bigDiv);
 }

Flex中ArrayCollection 与java中的ArrayList互转

java arrayList遍历的四种方法及Java中ArrayList类的用法

java arrayList遍历的四种方法及Java中ArrayList类的用法

package com.test;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ArrayListDemo {
  public static void main(String args[]){
    List<String> list = new ArrayList<String>();
    list.add("luojiahui");
    list.add("luojiafeng");
    //方法1
    Iterator it1 = list.iterator();
    while(it1.hasNext()){
      System.out.println(it1.next());
    }
    //方法2
    for(Iterator it2 = list.iterator();it2.hasNext();){
       System.out.println(it2.next());
    }
    //方法3
    for(String tmp:list){
      System.out.println(tmp);
    }
    //方法4
    for(int i = 0;i < list.size(); i ++){
      System.out.println(list.get(i));
    }
  }
}

 ps：Java中ArrayList类的用法

1、什么是ArrayList

ArrayList就是传说中的动态数组，用MSDN中的说法，就是Array的复杂版本，它提供了如下一些好处：

动态的增加和减少元素

实现了ICollection和IList接口

灵活的设置数组的大小

2、如何使用ArrayList

最简单的例子：

ArrayList List = new ArrayList(); 
for( int i=0;i <10;i++ ) //给数组增加10个Int元素 
List.Add(i); 
//..程序做一些处理 
List.RemoveAt(5);//将第6个元素移除 
for( int i=0;i <3;i++ ) //再增加3个元素 
List.Add(i+20); 
Int32[] values = (Int32[])List.ToArray(typeof(Int32));//返回ArrayList包含的数组

这是一个简单的例子，虽然没有包含ArrayList所有的方法，但是可以反映出ArrayList最常用的用法

3、ArrayList重要的方法和属性

1）构造器

ArrayList提供了三个构造器：
public ArrayList();
默认的构造器，将会以默认（16）的大小来初始化内部的数组
public ArrayList(ICollection);
用一个ICollection对象来构造，并将该集合的元素添加到ArrayList
public ArrayList(int);
用指定的大小来初始化内部的数组

2）IsSynchronized属性和ArrayList.Synchronized方法

IsSynchronized属性指示当前的ArrayList实例是否支持线程同步，而ArrayList.Synchronized静态方法则会返回一个ArrayList的线程同步的封装。

如果使用非线程同步的实例，那么在多线程访问的时候，需要自己手动调用lock来保持线程同步，例如：

ArrayList list = new ArrayList(); 
//... 
lock( list.SyncRoot ) //当ArrayList为非线程包装的时候

SyncRoot属性其实就是它自己，但是为了满足ICollection的SyncRoot定义，

这里还是使用SyncRoot来保持源代码的规范性

{ 
list.Add( “Add a Item” ); 
}

如果使用ArrayList.Synchronized方法返回的实例，那么就不用考虑线程同步的问题，这个实例本身就是线程安全的，实际上ArrayList内部实现了一个保证线程同步的内部类，ArrayList.Synchronized返回的就是这个类的实例，它里面的每个属性都是用了lock关键字来保证线程同步。

3）Count属性和Capacity属性

Count属性是目前ArrayList包含的元素的数量，这个属性是只读的。
Capacity属性是目前ArrayList能够包含的最大数量，可以手动的设置这个属性，但是当设置为小于Count值的时候会引发一个异常。

4）Add、AddRange、Remove、RemoveAt、RemoveRange、Insert、InsertRange

这几个方法比较类似

Add方法用于添加一个元素到当前列表的末尾
AddRange方法用于添加一批元素到当前列表的末尾
Remove方法用于删除一个元素，通过元素本身的引用来删除
RemoveAt方法用于删除一个元素，通过索引值来删除
RemoveRange用于删除一批元素，通过指定开始的索引和删除的数量来删除
Insert用于添加一个元素到指定位置，列表后面的元素依次往后移动
InsertRange用于从指定位置开始添加一批元素，列表后面的元素依次往后移动

另外，还有几个类似的方法：

Clear方法用于清除现有所有的元素
Contains方法用来查找某个对象在不在列表之中

其他的我就不一一累赘了，大家可以查看MSDN，上面讲的更仔细

5）Trimsize方法

这个方法用于将ArrayList固定到实际元素的大小，当动态数组元素确定不在添加的时候，可以调用这个方法来释放空余的内存。

6）ToArray方法

这个方法把ArrayList的元素copy到一个新的数组中。

4、ArrayList与数组转换

例1：

ArrayList List = new ArrayList(); 
List.Add(1); 
List.Add(2); 
List.Add(3);
Int32[] values = (Int32[])List.ToArray(typeof(Int32));

例2：

ArrayList List = new ArrayList(); 
List.Add(1); 
List.Add(2); 
List.Add(3);
Int32[] values = new Int32[List.Count]; 
List.copyTo(values);

上面介绍了两种从ArrayList转换到数组的方法

例3：

ArrayList List = new ArrayList(); 
List.Add( “string” ); 
List.Add( 1 ); 
//往数组中添加不同类型的元素
object[] values = List.ToArray(typeof(object)); //正确 
string[] values = (string[])List.ToArray(typeof(string)); //错误

和数组不一样，因为可以转换为Object数组，所以往ArrayList里面添加不同类型的元素是不会出错的，但是当调用ArrayList方法的时候，要么传递所有元素都可以正确转型的类型或者Object类型，否则将会抛出无法转型的异常。

5、ArrayList最佳使用建议

这一节我们来讨论ArrayList与数组的差别，以及ArrayList的效率问题

1）ArrayList是Array的复杂版本

ArrayList内部封装了一个Object类型的数组，从一般的意义来说，它和数组没有本质的差别，甚

定到实际元素的大小，当动态数组元素确定不在添加的时候，可以调用这个方法来释放空余的内存。

6）ToArray方法

这个方法把ArrayList的元素copy到一个新的数组中。

4、ArrayList与数组转换

例1：

ArrayList List = new ArrayList(); 
List.Add(1); 
List.Add(2); 
List.Add(3);
Int32[] values = (Int32[])List.ToArray(typeof(Int32));

例2：

ArrayList List = new ArrayList(); 
List.Add(1); 
List.Add(2); 
List.Add(3);
Int32[] values = new Int32[List.Count]; 
List.copyTo(values);

上面介绍了两种从ArrayList转换到数组的方法

例3：

ArrayList List = new ArrayList(); 
List.Add( “string” ); 
List.Add( 1 ); 
//往数组中添加不同类型的元素
object[] values = List.ToArray(typeof(object)); //正确 
string[] values = (string[])List.ToArray(typeof(string)); //错误

和数组不一样，因为可以转换为Object数组，所以往ArrayList里面添加不同类型的元素是不会出错的，但是当调用ArrayList方法的时候，要么传递所有元素都可以正确转型的类型或者Object类型，否则将会抛出无法转型的异常。

5、ArrayList最佳使用建议

这一节我们来讨论ArrayList与数组的差别，以及ArrayList的效率问题

1）ArrayList是Array的复杂版本

ArrayList内部封装了一个Object类型的数组，从一般的意义来说，它和数组没有本质的差别，甚至于ArrayList的许多方法，如Index、IndexOf、Contains、Sort等都是在内部数组的基础上直接调用Array的对应方法。

2）内部的Object类型的影响

对于一般的引用类型来说，这部分的影响不是很大，但是对于值类型来说，往ArrayList里面添加和修改元素，都会引起装箱和拆箱的操作，频繁的操作可能会影响一部分效率。
但是恰恰对于大多数人，多数的应用都是使用值类型的数组。
消除这个影响是没有办法的，除非你不用它，否则就要承担一部分的效率损失，不过这部分的损失不会很大。

3）数组扩容

这是对ArrayList效率影响比较大的一个因素。
每当执行Add、AddRange、Insert、InsertRange等添加元素的方法，都会检查内部数组的容量是否不够了，如果是，它就会以当前容量的两倍来重新构建一个数组，将旧元素copy到新数组中，然后丢弃旧数组，在这个临界点的扩容操作，应该来说是比较影响效率的。

例1：比如，一个可能有200个元素的数据动态添加到一个以默认16个元素大小创建的ArrayList中，将会经过：

16*2*2*2*2 = 256

四次的扩容才会满足最终的要求，那么如果一开始就以：

ArrayList List = new ArrayList( 210 );
的方式创建ArrayList，不仅会减少4次数组创建和copy的操作，还会减少内存使用。

例2：预计有30个元素而创建了一个ArrayList：

ArrayList List = new ArrayList(30);

在执行过程中，加入了31个元素，那么数组会扩充到60个元素的大小，而这时候不会有新的元素再增加进来，而且有没有调用Trimsize方法，那么就有1次扩容的操作，并且浪费了29个元素大小的空间。如果这时候，用：

ArrayList List = new ArrayList(40);

那么一切都解决了。
所以说，正确的预估可能的元素，并且在适当的时候调用Trimsize方法是提高ArrayList使用效率的重要途径。

4）频繁的调用IndexOf、Contains等方法（Sort、BinarySearch等方

法经过优化，不在此列）引起的效率损失
首先，我们要明确一点，ArrayList是动态数组，它不包括通过Key或者Value快速访问的算法，所以实际上调用IndexOf、Contains等方法是执行的简单的循环来查找元素，所以频繁的调用此类方法并不比你自己写循环并且稍作优化来的快，如果有这方面的要求，建议使用Hashtable或SortedList等键值对的集合。

ArrayList al=new ArrayList();
al.Add("How"); 
al.Add("are"); 
al.Add("you!");
al.Add(100); 
al.Add(200); 
al.Add(300);
al.Add(1.2); 
al.Add(22.8);

Java Arrays类方法

1:概述

主要谈一谈 Java使用fork/koin类 实现的并发排序 以及对于Stream流的支持的splitetor

• mismatch()   ->  寻找两个数组 第一次出现数据不一致的下标
• parallelPrefix() -> 对数组进行,累加求和
• parallelSetAll() -> 对数组进行置数,
• parallelSort()   -> 并行排序
• Spliterator() -> 对数组进行切分(切分后的数据为所有的数据的组合)
  • 奇数 x/2+1     11->6
  • 偶数  x/2    10 ==>5 

public class Use_Arrays {
      
    @Test
    public void test_mismatch() {
        int []x =new int[] {1,2,3,4};
        int []y =new int[] {1,3,4,5};
        int index = Arrays.mismatch(x, y);
        System.out.println(index);
    }
    
    @Test
    public void test_parallelPrefix() {
        int []x =new int[] {1,2,3,4};
        //f2=f1+f2
        //f3=f2+f3
        Arrays.parallelPrefix(x, (k,v)->k+v);
        System.out.println(Arrays.toString(x));
        
        // 实现1-100累加求和
        int []y =new int[100];
        Arrays.parallelSetAll(y, k->k=1);
        Arrays.parallelPrefix(y, (k,v)->k+v);
        System.out.println(Arrays.toString(y));
        
    }
    @Test
    public void test_parallelSetAll() {
        int []x =new int[100];
        x[0]=1;
        Arrays.parallelSetAll(x, y->y+1);
        System.out.println(Arrays.toString(x));
    }
    
    @Test
    public void test_parallSort() {
          IntStream stream = new Random().ints(0, 1000).limit(1000);
          int[] array = stream.toArray();
          System.out.println(Arrays.toString(array));
          Arrays.parallelSort(array);
          System.out.println(Arrays.toString(array));
    }
    
    @Test
    public void test_spliterator() {
        int []x =new int[11];
        Arrays.parallelSetAll(x, k->k+=1);
        System.out.println(Arrays.toString(x));
        
        Spliterator.OfInt int0_100 = Arrays.spliterator(x);
        
        int [] y=new int[(int) int0_100.estimateSize()];
        int i=0;
        System.out.println(int0_100.estimateSize());
        System.out.println(int0_100.characteristics());
        System.out.println(int0_100.getExactSizeIfKnown());
        
        //spliterator.forEachRemaining((int k)->System.out.println(k));
        
        OfInt int1_50 = int0_100.trySplit();
        OfInt int2_25 = int1_50.trySplit();
        int0_100.forEachRemaining((int k)->System.out.print(k+" "));
        System.out.println();
        int1_50.forEachRemaining((int k)->System.out.print(k+" "));
        System.out.println();
        int2_25.forEachRemaining((int k)->System.out.print(k+" "));
    }
}

2:使用Spliterator实现并行输出

    @Test
    public void definied_Sort() {
         IntStream stream = new Random().ints(0, 100).limit(100);
         int[] array = stream.toArray();
         Arrays.sort(array);
         final int NUMS=3;// 切分的次数
         
         ExecutorService thread_pool = Executors.newFixedThreadPool(10);
         
         Spliterator.OfInt cut1 = Arrays.spliterator(array);
         while(!thread_pool.isTerminated()) {
             thread_pool.submit(()->{
                    OfInt split = cut1.trySplit();
                     thread_pool.shutdown();
                 split.forEachRemaining((int k)->System.out.print(k+" "));
                 System.out.println();
             });
         }
    }

今天关于Java中Arrays类与Math类和java的arrays类的讲解已经结束，谢谢您的阅读，如果想了解更多关于1、基本类型包装类 2、System类 3、Math类 4、Arrays类 5、大数据运算、Flex中ArrayCollection 与java中的ArrayList互转、java arrayList遍历的四种方法及Java中ArrayList类的用法、Java Arrays类方法的相关知识，请在本站搜索。