Java学习笔记
第四章——流程控制与数组
条件结构
if控制的条件结构与switch控制的条件结构与C语言完全相同。
循环结构
for循环结构，while循环结构，do while循环结构也和C语言相同。使用break结束循环：正常用法与C语言相同，即在循环内加入break;当程序执行这一条命令时，将跳出该层循环；但Java中break还可以在后面加入一个标签，如下所示：
public class BreakTest {
public static void main
(String
[] args
){
outer
:
for (int i
= 0 ; i
< 10 ; i
++){
System
.out
.println("i的值为："+i
);
for (int j
= 0 ; j
< 3 ; j
++){
System
.out
.println("j的值为："+j
);
if(j
== 1)
break outer
;
}
}
}
}
执行结果如下：
i的值为：
0
j的值为：
0
j的值为：
1
同样的，continue也有与其相同的用法。
数组类型
数组元素的类型是唯一的，即一个数组里只能存储一种数据类型的数据。
定义数组
Java语言支持两种语法格式来定义数组
type
[] arrayName
;
type arrayName
[];
推荐使用第一种方式，变量类型就是type[]，而变量名则是arrayName。
注意：定义数组时不能指定数组的长度。
Java语言中数组必须先初始化，然后才可以使用。所谓的初始化，就是为数组的数组元素分配内存空间，并为每个数组元素赋初始值数组的初始化有两种方式：
静态初始化：初始化时由程序员显示指定每个数组元素的初始值，由系统决定数组长度动态初始化：初始化时程序员只指定数组长度，由系统为数组元素分配初始值。
静态初始化
静态初始化的语法格式如下：
arrayName
= new type[] {element1
,element2
,element3
...}
在上面的语法格式中，前面的type就是数组元素的数据类型，此处的type必须与定义数组变量时所使用的type相同，也可以是定义数组时所制定的的type子类，并使用花括号把所有的数组元素括起来，多个数组元素之间以英文逗号隔开，定义初始化的花括号紧跟在[]之后。值得指出的是，执行静态初始化时，显式指定的数组元素值的类型必须与new关键字后的type类型相同，或者是其子类的实例。下面代码定义了使用这三种形式来进行静态初始化：
public class ArrayTest {
public static void main(String
[] args
){
int[] intArr
;
intArr
= new int[] {5,6,7,8};
Object
[] objArr
;
objArr
= new String[] {"lancibe", "java"};
Object
[] objArr2
;
objArr2
= new Object[] {"lancibe","java"};
}
}
因为Java语言是面向对象的编程语言，能很好的支持子类和父类的继承关系：子类实例是一种特殊的父类实例。在上面的程序中，String类型是Object类型的子类，即字符串是一种特殊的Object实例。除此之外，静态初始化还有如下简化的语法形式：
type
[] arrayName
= {element1
, element2
, element3
...};
这其实就是将数组定义和数组初始化同时完成
动态初始化
动态初始化只指定数组的长度，由系统为每个数组元素指定初始值。动态初始化的语法格式如下：arrayName = new type[length]在上面的语法中，需指定一个int类型的length参数，这个参数指定了数组的长度，也就是可以容纳数组元素的个数。执行动态初始化是，程序员指定了数组的长度，系统按如下规则分配初始值
整数类型：0浮点类型：0.0字符类型：’\u0000’布尔类型：false引用类型：null 要注意不要同时使用静态初始化和动态初始化，也就是说，不要在进行数组初始化时，既指定了数组的长度，也为每个数组元素分配初始值。
使用数组
数组最常用的用法就是访问数组元素，包括对数组元素进行赋值和取出数组元素的值。访问数组元素都是通过在数组引用变量后紧跟一个方括号[]，方括号里是数组元素的索引。索引是从0开始的。
foreach循环
Java提供了一种简单的循环：foreach循环。这种循环遍历数组和集合（集合在后面会学到），无需获得数组和集合的长度，无需根据所引来访问数组元素和集合元素，foreach循环会自动遍历数组和集合中的每一个元素。foreach循环的语法格式如下：
for (type variableName
: array
| collection
)
{
}
下面程序将示范如何使用foreach循环来遍历数组元素
public class ForEachTest {
public static void main(String
[] args
){
String
[] names
= {"lancibe", "123", "linux"};
for (String name
:names
) {
System
.out
.println(name
);
}
}
}
通常不要对循环变量进行赋值，没有什么意义，且极容易引起错误。
深入数组
内存中的数组
数组引用变量只是一个引用，这个引用变量可以指向任何有效的内存，只有当该引用指向有效内存后，才可以通过该数组变量来访问数组元素与所有引用变量相同的是，引用变量是访问真实对象的根本方式。也就是说，如果希望在程序中访问数组对象本身，则只能通过这个数组的引用变量来访问它。实际的数组对象被存储在堆(heap)中，如果引用该数组对象的数组引用变量是一个局部变量，那么他被存储在栈(stack)内存中。如果堆内存中数组不再有任何引用变量指向自己，则这个数组将成为垃圾，该数组所占的内存将会被系统的垃圾回收机制回收。因此，为了让垃圾回收机制回收一个数组所占的内存空间，可以将该数组变量赋值为null，也就切断了数组引用变量和实际数组之间的引用关系，实际的数组也就成了垃圾。只要类型相互兼容，就可以让一个数组变量指向另一个实际的数组，这种操作会让人产生数组的长度可变的错觉。如下程序所示
public class ArrayInRam {
public static void main(String
[] args
){
int[] a
= {5, 7, 20};
int[] b
= new int[4];
System
.out
.println("b的长度为" + b
.length
);
for(int temp
: a
){
System
.out
.println(temp
);
}
for(int temp
: b
){
System
.out
.println(temp
);
}
b
= a
;
System
.out
.println("b的长度为" + b
.length
);
}
}
运行该程序后，发现先输出b的长度为4，然后依次遍历a和b，最后输出了b的长度为3。看起来数组长度是可变的，但其实，只是b的指向变了，也就是原来a的引用的数组现在有了两个引用，而原来b引用的数组现在失去引用，变成垃圾。
引用类型数组的初始化
引用类型数组的数组元素是引用，因此情况更为复杂。每个数组元素里存储的还是引用，指向另一块内存，这块内存里存储了有效数据。为了更好的说明引用类型数组的运行过程，下面先定义一个Person类（所有类都是引用类型）。Person类代码如下
class Person{
public int age
;
public double height
;
public void info(){
System
.out
.println("我的年龄是："+age
+"，我的身高是："+height
);
}
}
下面程序将定义一个Person[]数组，接着动态初始化这个Person[]数组，并为这个数组的每一个元素指定值。
class Person{
public int age
;
public double height
;
public void info(){
System
.out
.println("我的年龄是："+age
+"，我的身高是："+height
);
}
}
public class ReferenceArrayTest {
public static void main(String
[] args
){
Person
[] students
;
students
= new Person[2];
Person zhang
= new Person();
zhang
.age
= 15;
zhang
.height
= 158.;
Person lee
= new Person();
lee
.age
= 16;
lee
.height
= 161.;
students
[0] = zhang
;
students
[1] = lee
;
lee
.info();
students
[1].info();
}
}
可以发现，执行结果完全一样，这说明，lee和student[1]指向同一个内存区，引用了同一个Person对象，也具有相同的效果。对于多维数组，在进行初始化时，可以只指定最左边维的大小、也可以一次指定每一维的大小。二维数组是一维数组，其数组元素是一维数组。
Java 8 增强的工具类：Arrays
Java提供的Arrays类里包含的一些static修饰的方法可以直接操作数组，这个Arrays类里包含如下几个static修饰的方法（static修饰的方法可以直接通过类名调用）
int binarySearch(type
[] a
, type key
):使用二分法查询key元素值在数组a里出现的索引。若数组不包含key元素值，则返回负数，调用该方法时要求数组中元素已经按序排列，这样才能得到正确结果。
int binarySearch(type
[] a
, int fromIndex
, int toIndex
, type key
):与前一个方法相似，不过只搜索fromIndex到toIndex索引之间的排好序的元素。
type
[] copyOf(type
[] original
, int length
):这个方法会把original数组复制成一个新数组，其中length是新数组的长度。如果length小于original数组的长度，这新数组就是原数组的前length个元素；如果length大于original
.length，则后面自动补充
0或null
type
[] copyOfRange(type
[] original
, int from
, int to
):这个方法与前面相似，但是只拷贝from索引到to索引的元素。
boolean equals(type
[] a
, type
[] a2
):如果两数组长度和元素完全相同，则返回
true
void fill(type
[] a
, type val
):将a的所有元素赋值为val
void fill(type
[] a
, int fromIndex
, int toIndex
, type val
):懂的都懂
^^
void sort(type
[] a
):该方法对a数组的数组元素进行排序
void sort(type
[] a
, int fromIndex
, int toIndex
)
String
toString(type
[] a
):该方法将一个数组转换成一个字符串。该方法按顺序把多个数组元素连缀在一起，多个数组元素使用英文逗号和空格来隔开
下面示范了Arrays类的用法
import java
.util
.Arrays
;
public class ArraysTest {
public static void main(String
[] args
){
int[] a
= new int[]{3, 4, 5, 6};
int[] a2
= new int[] {3, 4, 5, 6};
System
.out
.println("a和a2是否相等："+ Arrays
.equals(a
, a2
));
int[] b
= Arrays
.copyOf(a
, 6);
System
.out
.println("b的数组元素为："+Arrays
.toString(b
));
Arrays
.fill(b
, 2, 4, 1);
System
.out
.println("b的数组元素为："+Arrays
.toString(b
));
Arrays
.sort(b
);
System
.out
.println("b的数组元素为："+ Arrays
.toString(b
));
}
}
输出结果是
a和a2是否相等：
true
b的数组元素为：
[3, 4, 5, 6, 0, 0]
b的数组元素为：
[3, 4, 1, 1, 0, 0]
b的数组元素为：
[0, 0, 1, 1, 3, 4]
Arrays类处于java.util包下，为在程序中使用Arrays类，必须在程序中导入java.util.Arrays类，如该程序第一行所示。
除此之外，在System类里也包含了一个static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)方法，该方法可以将src数组里的元素值赋给dest数组的元素，其中srcPos指定从数组的第几个元素开始赋值，length参数指定将src数组的多少个元素值赋给dest数组的元素。
Java 8 增强了Arrays类的功能，为Arrays类提供了一些工具方法，这些工具方法可以充分利用CPU并行能力来提高设值、排序的技能。下面是Java 8 为Arrays类增加的工具方法。
void parallelPrefix(xxx
[] array
, XxxBinaryOperator op
):该方法使用op参数指定的计算公式计算得到的结果作为新的元素，op计算公式包括left、right两个形参，其中left代表数组中前一个索引处的元素，right代表数组中当前索引处的元素，当计算第一个新数组元素时，left的值默认为
1
void parallelPrefix(xxx
[] array
, int fromIndex
, int toIndex
, XxxBinatyOperator op
):该方法与上相似
void setAll(xxx
[] array
, IntToXxxFunction generator
):该方法使用指定的生成器
(generator
)为所有数组元素设置值，该生成器控制数组元素的值的生成算法。
void parallelSetAll(xxx
[] array
, IntToXxxFunction generator
):增加并行能力，利用多CPU并行来提高性能
void parallelSort(xxx
[] a
)
void parallelSort(xxx
[] a
, int fromIndex
, int toIndex
)
Spliterator
.OfXxx
spliterator(xxx
[] array
):将该数组的所有元素转换成对应的Spliterator对象
Spliterator
.OfXxx
spliterator(xxx
[] array
, int startInclusive
, int endExclusive
):仅转换startInclusive到endExclusive索引的元素
XxxStream
stream(xxx
[] array
):该方法将数组转换为Stream，Stream是Java
8 新增的流式编程的API。
XxxStream
stream(xxx
[] array
, int StartInclusive
, int endExclusive
)
上面方法列表中，所有以parallel开头的方法都表示该方法可利用CPU并行的能力来提高性能。上面方法中的xxx代表不同的数据类型，比如处理int[]型数组时应将xxx换成int，处理long[]型的数组时应将xxx换成long。下面程序示范了Java 8 为Arrays类新增的方法。
import java
.util
.Arrays
;
import java
.util
.function
.IntBinaryOperator
;
import java
.util
.function
.IntUnaryOperator
;
public class ArraysTest2 {
public static void main(String
[] args
){
int[] arr1
= new int[] {3, -4, 25, 16, 30, 18};
Arrays
.parallelSort(arr1
);
System
.out
.println(Arrays
.toString(arr1
));
int[] arr2
= new int[] {3, -4, 25, 16, 30, 18};
Arrays
.parallelPrefix(arr2
, new IntBinaryOperator() {
public int applyAsInt(int i
, int i1
) {
return i
*i1
;
}
});
System
.out
.println(Arrays
.toString(arr2
));
int[] arr3
= new int[5];
Arrays
.parallelSetAll(arr3
, new IntUnaryOperator() {
public int applyAsInt(int i
) {
return i
*5;
}
});
System
.out
.println(Arrays
.toString(arr3
));
}
}
输出结果如下：
[-4, 3, 16, 18, 25, 30]
[3, -12, -300, -4800, -144000, -2592000]
[0, 5, 10, 15, 20]
