java语言基础与流程控制

一维数组定义:

1.声明

类型[]  数组名;
或
类型  数组名[];
eg:
    int[] score;
    String[] names;

2.初始化:声明的长度，数组的元素也可以确定

    2.1初始化的位置不同，分静态，动态初始化

    静态初始化：声明数级的同时初始化（开劈空间，一当初始化不能再改变数组的大小了）
        int[] arr = new int[5];
        int[] arr = new int[7]{10,20,30,50,40};
        int[] arr = {10,20,30,50,40};
        

    2.2动态初始化:声明和初始化分别进行

        数组名= new 类型[整数长度];

        
3.数组的使用

    1.下标:数组名[下标]
        整数（变量表示，常量表示）
        arr[n];//n必须是一个int类型的变量
        arr[1];//常量
        从0开始，结束是数组长度-1
    2.length，用于数组的长度(数组成员个数)
        int len = arr.length;
        System.out.println("数组arr的元素个数是:"+len);

案例1（数组）

package com.nf.ch02;
public class Demo3{
    public static void test1(){
        int[][] arr1 = new int[3][];
        int[][] arr2 = new int[3][4];
        int[][] arr3 = new int[][]{{1,2,3,8},{6,5,4}};
        int[][] arr4 = {{1,2,3},{6,5,4,7}};
        
        arr1[0] = new int[2];
        arr1[1] = new int[3];
        arr1[2] = new int[4];
        
        String[][] address = new String[3][];
        address[0] = new String[2];
        address[1] = new String[3];
        address[2] = new String[4];
        
        address[0][0] = new String("aaa");
        address[0][1] = "bbb";
        
        address[1][0] = "ccc";
        address[1][1] = "ddd";
        address[1][2] = "eee";
        
        address[2][0] = new String("fff");
        address[2][1] = new String("ggg");
        address[2][2] = new String("hhh");
        address[2][3] = new String("kkk");
        
        
        
        System.out.println("arr4数组的内容:");
        for(int[] arr : arr4){
            for(int ele : arr){
                System.out.print(ele+"\t");
            }
            System.out.println();
        }
        System.out.println("arr3数组的内容:");
        for(int[] arr : arr3){
            for(int ele : arr){
                System.out.print(ele+"\t");
            }
            System.out.println();
        }
        System.out.println("arr2数组的内容:");
        for(int[] arr : arr2){
            for(int ele : arr){
                System.out.print(ele+"\t");
            }
            System.out.println();
        }
        System.out.println("arr1数组的内容:");
        for(int[] arr : arr1){
            for(int ele : arr){
                System.out.print(ele+"\t");
            }
            System.out.println();
        }
        
        System.out.println("arr1数组的内容:");
        for(int i=0; i<arr1.length; i++){
            for(int j=0; j<arr1[i].length; j++){
                System.out.print(arr1[i][j]+"\t");
            }
            System.out.println();
        }
        
    }
    public static void test2(){
        //double n=NaN;
        String str=null;
        //System.out.println(n);
        System.out.println(str.length());
    }
    public static void test3(){
        int[][] arr = new int[9][];
        //初始化
        for(int i=0; i<9; i++){
            arr[i] = new int[i+1];
            for(int j=0;j<i+1; j++){
                if(j==0 || j==i)
                    arr[i][j]=1;
                else
                    arr[i][j] = arr[i-1][j]+arr[i-1][j-1];
            }
            
        }
        //显示
        for(int[] nums:arr){
            for(int ele : nums){
                System.out.print(ele+"\t");                    
            }
            System.out.println();
        }
        
    }
    public static void main(String[] args){
        test3();
    }
}

案例2

package com.nf.ch02;
import java.text.*;
import java.util.*;
public class Demo4{
    public static void test1(){
        String str = "1011";
        int num1 = Integer.parseInt(str);//当十进制解析
        int num2 = Integer.parseInt(str,2);//当二进制解析
        int num3 = Integer.parseInt(str,8);//当八进制解析
        int num4 = Integer.parseInt(str,16);//当十六进制解析
        
        System.out.println("十进制数1011的整数是:"+num1);
        System.out.println("二进制数1011的整数是:"+num2);
        System.out.println("八进制数1011的整数是:"+num3);
        System.out.println("十六进制数1011的整数是:"+num4);
    }
    
    public static void test2(){
        int num = 99;
        String num1 = Integer.toBinaryString(num);//二进制
        String num2 = Integer.toOctalString(num);//八进制
        String num3 = Integer.toHexString(num);//十六进制
        
        System.out.println("99的二进制数表示为:"+num1);
        System.out.println("99的八进制数表示为:"+num2);
        System.out.println("99的十六进制数表示为:"+num3);
    }
    //将一个小数始终保留两小数位输出
    public static void test3(double num){
        NumberFormat nf = new DecimalFormat("￥：#0.00");
        String rs = nf.format(num);
        System.out.println(num+":"+rs);
    }
    //日期与字符串
    public static void test4()  throws Exception{
        DateFormat df = new SimpleDateFormat("yyyy/MM/dd");
        String dateStr = "2018/3/10";
        Date date = df.parse(dateStr);
    }
    
    public static void test5() throws Exception{
        Scanner input = new Scanner(System.in);
        System.out.print("请输入日期(yyyy-mm-dd):");
        String dateStr = input.next();
        
        //输入的日期字符串解析为日期对象
        DateFormat df1 = new SimpleDateFormat("yyyy-MM-dd");
        Date date = df1.parse(dateStr);
        
        //将日期对象格式化为指定模式的字符串
        DateFormat df2 = new SimpleDateFormat("是今年的第D天,E");
        String rs = df2.format(date);
        
        System.out.println(rs);        
        
    }
    public static void main(String[] args)  throws Exception{
        test5();
        /*test3(10);
        test3(0.1245);
        test3(10.5);
        test3(10.12);
        test3(10.126F);
        test3(10.126);
        test3(10.121212);*/
    }
}

案例3

package com.nf.ch02;
import java.text.*;
import java.util.*;
public class Demo5{
    public static void test1(){
        int i=100;
        //将int类型的值包装到Integer类的对象中
        Integer i2 = new Integer(i);
        Integer i2_2 = Integer.valueOf(102);
        
        //将数字字符串类型的值包装到Integer类的对象中
        String str="100";        
        Integer i3 = new Integer(str);
        Integer i3_2 = Integer.valueOf(str);
        
        //将"F0F0"十六进制数字字符串的值包装到Integer对象中
        Integer i4 = Ineger.valueOf("F0F0",16);
        
        int n= i4.intValue();
        
        Integer num = 100;
        short s = num.shortValue();
        
        int num2 = 10;
        short s2 = (short)num2;
    }
        
    public static void main(String[] args)  throws Exception{
        
    }
}

 

String str = "123AF";
字符串转整数

    int n = Integer.parseInt(str);
    short n = Short.parseShort(str);
    long n = Long.parseLong(str);
字符串转小数
    float f = Float.parseFloat(str);
    double d = Double.parseDouble(str);

    
int num = 100;    
十进制整数转不同进制的字符串
String str2 = Integer.ToBinaryString(num);
String str8 = Integer.ToOctalString(num);
String str16 = Integer.ToHexString(num);

 

double num=10.5;

十进制浮点数转十六进制的字符串
String str = Double.ToHexString(num);
...     

有字符串"AF0F5"
1.按十六进制解析为一个long类型的值保存
2.按十六进制解析为一个Long类型的包装类型对象保存

有整数108
1.按十进制格式为字符串形式保存
2.按十进制包装到Ingeter对象中

有包装类的对象"98",Integer numObj = 98;
1.取出对应十进制数，保存到int类型的变量中
2.取出对应十进制数，以二进制形式保存到String类型的变量中

有日期字符串"2018-10-12",解析为一个日期对象并保存