第四章.流程控制与数组

流程控制结构：

分支结构

　　根据分支条件来选择性的执行某段代码。

　　if：

　　switch：

　　　　case语句后面只能是byte、short、char、int四种整型类型，枚举类型和Java.lang.String类型（从Java 7才允许）。

　　　　default语句不省略。

　　break：

　　　　break语句可以结束switch语句、while、do while、for语句但是结束不了if语句。

　　　　Java中海油一种break标签，可以结束外层循环：

public class BreakTest2{
    public static void main(String[] args){
        //外层循环，outer作为标识符
        outer:
        for(int i = 0; i < 5; i++){
            //内层循环
            for(int j = 0; j < 3; j++){
                System.out.println("i的值为：" + i + " j的值为：" + j);
                if(j == 1){
                    //跳出outer标签所标识的循环
                    break outer;
                }
            }
        }
    }
}

　　　　记住：这个外层循环标签是结束外层循环，不是跳到外层循环重新执行，切记！　

　　　　break后的标签必须是一个有效的标签，即这个标签必须在其所在循环的外层循环之前定义。

　　　　标签和循环语句之间不要加任何语句。

　continue：

　　　　用在for语句中。

循环结构

　　根据循环条件，重复执行某段代码。

　　while：

　　do while：

　　for：

　　foreach(jdk 5)：

数组类型：

　　java的数组要求所有的数组元素具有相同的数据元素，即一个数组中只能存储一种数据类型的数据。

　　数组也是一种数据类型，它本身是一种引用类型：

　　　　int[] arrayName;//推荐使用这种

　　　　int arrayName[];

　　数组初始化：

　　　　静态初始化：

　　　　　　int[] arrayName;

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

　　　　　　或者定义初始化同时完成：

　　　　　　　　int[] a = {5, 6, 7, 8};

　　　　动态初始化：

　　　　　　int[] arrayName = new int[5];

　　数组不要同时使用静态初始化和动态初始化：

　　　　//错误的写法，int[]是类型，中括号中不能有值。

　　　　//错误的写法，不能同时使用静态和动态初始化数组。

　　　　

　　Java中各类型的默认值：

　　　　整型（byte，short，int，long）：0

　　　　浮点型（float，double）：0.0

　　　　字符型（char）：‘u0000’

　　　　布尔类型（boolean）：false

　　　　引用类型（类，接口，数组）：null

使用数组：

　　访问数组元素：

　　　　若访问数组元素时指定的索引值小于0，或者大于等于数组长度，编译程序不会出现任何错误，但是运行时会出现异常：java.lang.ArrayIndexOutOfBoundsException：N

　　　　(数组索引越界异常)，异常信息后的 N 就是程序员试图访问的数组索引。

　　所有数组都提供了一个length的属性，可以防止越界访问：

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

foreach循环：

　　可以循环遍历数组和集合，使用foreach循环遍历数组和集合元素时，无需获得数组和集合的长度，无需根据索引来访问数组元素和集合元素，foreach循环自动遍历数组和集合

　　每个元素：

public class ArrayTest{
    public static void main(String[] args){
        String[] books = {"疯狂Java讲义", "疯狂Android讲义"};
        for(String book : books){
            book = "疯狂Ajax讲义";
            System.out.println(book);
        }
        System.out.println(books[0]);
        System.out.println(books[1]);
    }
}

　　

　　想一想上面的输出结果，并理解为什么会有这样的结果？

Java 8增强工具类：Arrays

Arrays类中包含了如下几个Static修饰的方法。//类中静态方法可以用 类名.方法名()调用。省去了创建对象的麻烦。

　　1.int binarySearch(type[] a, type key);//使用二分法查询key元素在a数组中的索引值，若不包含key，则返回负数。a数组中元素已经按升序排列

　　2.int binarySearch(type[] a, int fromIndex, int to Index, type key);//使用二分法查询key元素在a数组中的索引值，只搜索a数组中从fromIndex到toIndex索引的元素，若不

　　　　包含key，则返回负数。a数组中元素已经按升序排列

　　3.type[] copyOf(type[] original, int length);//把original数组复制成一个新数组，length是新数组的长度。若length小于original数组的长度，则新数组就是原数组前面length个

　　　　元素；若length大于original数组的长度，则新数组的前面元素就是原数组的所有元素，后面按java默认值补充。

　　4.type[] copyOfRange(type[] original, int from, int to);//和上面方法相似，但是只复制从from到to索引的元素。

　　5.boolean equals(type[] a, type[] a2);//若a数组和a2数组的长度相同，且两者中元素也一一相同，该方法将返回true

　　6.void fill(type[] a, type val);//把a数组的所有元素都赋值为val

　　7.void fill(type[] a, int fromIndex, int toIndex, type val);//与上面方法类似，但是只将fromIndex到toIndex索引的元素赋值为val

　　8.void sort(type[] a);//对a数组的数组元素进行排序，为升序

　　9.void sort(type[] a, int fromIndex, int toIndex);//与上面方法相似，但是只将fromIndex到toIndex索引的元素排序，为升序

　　10.String toString(type[] a);//将一个数组转换为字符串，若数组元素为0,1,2,3,4，则输出为[0, 1, 2, 3, 4]，前后有中括号，中间以逗号和空格间隔。

数组应用：

把一个4位数字字符串转换成一个中文读法：

import java.util.Arrays;

public class Num2Rmb{
    private String[] hanArr = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};
    
    private String[] unitArr = {"十", "百", "千"};
    
    /**
    *把一个浮点数分解成整数部分和小数部分字符串
    *@param num 需要被分解的浮点数
    *@return 分解出来的整数部分和小数部分。第一个数组元素是整数部分，第二个数组是小数部分
    */
    private String[] divide(double num){
        
        //将一个浮点数前值类型转换为long型，即得到它的整数部分
        long zheng = (long) num;
        
        //浮点数减去整数部分，得到小数部分，小数部分乘以100后再取整得到两位小数
        int xiao = (int) ((num - zheng) * 100);
        
        //下面用了两种方法把证书转换为字符串
        return new String[] {zheng + "", String.valueOf(xiao)};
    }
    
    /**
    *把一个四位的数字字符串变成汉字字符串
    *@param numStr 需要被转换的四位的数字字符串
    *@return 四位的数字字符串被转换成汉字字符串
    */
    private String toHanStr(String numStr){
        String result = "";
        
        //防止numStr数字字符串开头为0，先把其转换为整型，再转换为数字字符串
        int numInt = Integer.parseInt(numStr);
        numStr = numInt + "";
        
        int numLen = numStr.length();
        
        //找出从右往左 数 不是零的位置
        int minimumNot0 = 0;
        while((!numStr.equals("0")) && numStr.charAt(numLen - 1 - minimumNot0) == '0'){
            minimumNot0++;
        }
        
        //依次遍历数字字符串的每一位数字（除从右往左 数 是零数字）,
        for(int i = 0; i < (numLen - minimumNot0); i++){
            
            //把char型数字转换成int型数字，因为它们的ASCII码值恰好相差48
            //因此把char型数字减去48得到int型数字，例如'4'被转换成4
            int num = numStr.charAt(i) - 48;
            
            //如果不是最后一位数字，而且数字不是零，则需要添加单位（千、百、十）
            if( i != numLen - 1 && num != 0){
                result += hanArr[num] + unitArr[numLen - 2 - i];
            }else{
                
                //否则不要添加单位
                result += hanArr[num];
                
                //判断数字字符串中间有几个零
                while((i != (numLen - 1)) && (numStr.charAt(i + 1) == '0')){
                    i++;
                }
            }
        }
        result += "元";
        return result;
    }
    
    public static void main(String[] args){
        Num2Rmb nr = new Num2Rmb();
        
        //测试把一个浮点数分解成整数部分和小数部分
        System.out.println(Arrays.toString(nr.divide(236711125.129)));
        
        //测试把一个四位的数字字符串变成汉字字符串
        System.out.println(nr.toHanStr("0000"));
        System.out.println(nr.toHanStr("0001"));
        System.out.println(nr.toHanStr("0010"));
        System.out.println(nr.toHanStr("0011"));
        System.out.println(nr.toHanStr("0100"));
        System.out.println(nr.toHanStr("0101"));
        System.out.println(nr.toHanStr("0110"));
        System.out.println(nr.toHanStr("0111"));
        System.out.println(nr.toHanStr("1000"));
        System.out.println(nr.toHanStr("1001"));
        System.out.println(nr.toHanStr("1010"));
        System.out.println(nr.toHanStr("1011"));
        System.out.println(nr.toHanStr("1100"));
        System.out.println(nr.toHanStr("1101"));
        System.out.println(nr.toHanStr("1110"));
        System.out.println(nr.toHanStr("1111"));
    }
}

GitHub链接：

https://github.com/lanshanxiao/-Java-

1 java中的length属性是针对数组说的,比如说你声明了一个数组,想知道这个数组的长度则用到了length这个属性.
2 java中的length()方法是针对字符串String说的,如果想看这个字符串的长度则用到length()这个方法.
3.java中的size()方法是针对泛型集合说的,如果想看这个泛型有多少个元素,就调用此方法来查看!

 Integer类中parseInt()和valueOf()的区别：

　　static int parseInt(String s) 
        　　  将字符串参数作为有符号的十进制整数进行分析。 
　　static Integer valueOf(int i) 
         　　 返回一个表示指定的 int 值的 Integer 实例。 
　　static Integer valueOf(String s) 
         　　 返回保持指定的 String 的值的 Integer 对象。

int转换为String，String转换为int的方法：

int -> String

int i=12345;
String s="";
第一种方法：s=i+"";
第二种方法：s=String.valueOf(i);
这两种方法有什么区别呢？作用是不是一样的呢？是不是在任何下都能互换呢？

String -> int

s="12345";
int i;
第一种方法：i=Integer.parseInt(s);
第二种方法：i=Integer.valueOf(s).intValue();
这两种方法有什么区别呢？作用是不是一样的呢？是不是在任何下都能互换呢？

以下是答案：

第一种方法：s=i+""; //会产生两个String对象
第二种方法：s=String.valueOf(i); //直接使用String类的静态方法，只产生一个对象

第一种方法：i=Integer.parseInt(s);//直接使用静态方法，不会产生多余的对象，但会抛出异常
第二种方法：i=Integer.valueOf(s).intValue();//Integer.valueOf(s) 相当于 new Integer(Integer.parseInt(s))，也会抛异常，但会多产生一个对象

--------------------------------------------------------------------
1如何将字串 String 转换成整数 int?

A. 有两个方法:

1). int i = Integer.parseInt([String]); 或
i = Integer.parseInt([String],[int radix]);

2). int i = Integer.valueOf(my_str).intValue();

注: 字串转成 Double, Float, Long 的方法大同小异.
2 如何将整数 int 转换成字串 String ?
A. 有叁种方法:

1.) String s = String.valueOf(i);

2.) String s = Integer.toString(i);

3.) String s = "" + i;

注: Double, Float, Long 转成字串的方法大同小异.