java与scala数组及集合的基本操作对比

def main(args: Array[String]): Unit = {

     //new一个大小不变的数组

     val nums = new Array[Int]( 10 ) //会被初始化为0

     val s = Array( "hello" , "world" ) //使用两个字符串初始化数组（记住，这里不需要new）

     s( 0 ) = "good bye" //使用()来访问数组

}

public static void main(String[] args) {

     int [] nums = new int [ 10 ];

     String[] s = new String[]{ "hello" , "world" };

     s[ 0 ] = "goodbye" ;

}

def main(args: Array[String]): Unit = {

     val b = ArrayBuffer[Int]() //初始化

     //或者

     //    val b = new ArrayBuffer[Int]

     b += 1 //添加一个元素

     b += ( 1 , 2 , 3 , 4 , 5 ) //添加多个元素在末尾

     println(s "b:$b" ) //b:ArrayBuffer(1, 1, 2, 3, 4, 5)

     b ++= Array( 8 , 1 , 34 ) //一次添加一个数组，注意这里是数组

     println(s "b:$b" ) //b:ArrayBuffer(1, 1, 2, 3, 4, 5, 8, 1, 34)

     b.trimEnd( 3 ) //移除最后三个元素

     println(s "b:$b" ) //b:ArrayBuffer(1, 1, 2, 3, 4, 5)

}

public static void main(String[] args) {

     List<Integer> list = new ArrayList<>();

     list.add( 1 );

     List<Integer> list2 = new ArrayList<>();

     list2.add( 1 );

     list2.add( 2 );

     list2.add( 3 );

     list2.add( 4 );

     list2.add( 5 );

     list.addAll(list2);

     //java一次要添加1，2，3，4，5就麻烦很多了

     // 当然使用guava的Lists.newArrayList看起来代码会简单些

     // 或者使用下面的Arrays.asList也会简单些，最主要的原因是直接构造一个含有多个数字的list原生的java支持的不好

     System.out.println(list); //[1, 1, 2, 3, 4, 5]

     list.addAll(Arrays.asList( 1 , 2 , 3 , 4 , 5 ));

     System.out.println(list); //[1, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]

     //java没有提供原生的，移除最后5个元素的函数

     list.add( 1 , 6 ); //List一次只能添加一个元素

     System.out.println(list); //[1, 6, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]

     list.remove( 1 );

     System.out.println(list); //[1, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]

     //list也不支持，移除第index上的连续n个数字

     Object[] array = list.toArray(); //转数组

     Arrays.asList(array); //转list

}

def main(args: Array[String]): Unit = {

   val a = Array( 1 , 2 , 3 , 4 , 5 )

   for (i <- 0 until a.length) {

     println(s "i:$i value:${a(i)}" )

   }

   println( "-----------" )

   //遍历隔一个

   for (i <- 0 until a.length by 2 ) {

     println(s "i:$i value:${a(i)}" )

   }

   println( "-----------" )

   //倒着遍历

   for (i <- 0 until a.length reverse) {

     println(s "i:$i value:${a(i)}" )

   }

   println( "-----------" )

   //如果不需要index

   for (ele <- a) {

     println(s "value:${ele}" )

   }

}

public static void main(String[] args) {

     int [] a = new int []{ 1 , 2 , 3 , 4 , 5 };

     for ( int i = 0 ; i < a.length; i++) {

         System.out.println( "index:" + i + ",value:" + a[i]);

     }

     System.out.println( "-----------------" );

     //遍历隔着2

     for ( int i = 0 ; i < a.length; i += 2 ) {

         System.out.println( "index:" + i + ",value:" + a[i]);

     }

     System.out.println( "-----------------" );

     //倒着遍历

     for ( int i = a.length - 1 ; i >= 0 ; i--) {

         System.out.println( "index:" + i + ",value:" + a[i]);

     }

     System.out.println( "-----------------" );

     //不关心index

     for ( int value : a) {

         System.out.println( "value:" + value);

     }

}

int [] a = new int []{ 1 , 2 , 5 };

val a=Array( 1 , 2 , 5 )

final class Array[T](_length: Int) extends java.io.Serializable with java.lang.Cloneable {

   /** The length of the array */

   def length: Int = throw new Error()

   // The element at given index.

   def apply(i: Int): T = throw new Error()

   // Update the element at given index.

   def update(i: Int, x: T) { throw new Error() }

   //Clone the Array.

   override def clone(): Array[T] = throw new Error()

}

/** Creates an array of `Int` objects */

  // Subject to a compiler optimization in Cleanup, see above.

  def apply(x: Int, xs: Int*): Array[Int] = {

    val array = new Array[Int](xs.length + 1 )

    array( 0 ) = x

    var i = 1

    for (x <- xs.iterator) { array(i) = x; i += 1 }

    array

  }