Java基础_2

1. 类型转换

自动转换 由小到大

byte、short、char‐‐>int‐‐>long‐‐>float‐‐>double

double num1 = 100F;  // 100.0
float num2 = 1000L;  //1000.0
long num3 = 10;    // 10

强制转换

byte a = 10;
byte b = 10;
byte c = (byte)(a + b); // a+b为int型，需要强制转化为byte型

注意事项

1. 精度损失
2. short、byte、char 可以加减，自动转换为int型然后再计算

2. Scanner

import java.util.Scanner;

2.1 三种输入数据流方式：

// 用户输入
    Scanner sc = new Scanner(System.in);
    int i = sc.nextInt();
// 文件读取
      Scanner sc = new Scanner(new File("myNumbers"));
      while (sc.hasNextLong()) {
          long aLong = sc.nextLong();
      }
// 字符串读取
     String input = "1 fish 2 fish red fish blue fish";
     Scanner s = new Scanner(input).useDelimiter("\\s*fish\\s*");
     System.out.println(s.nextInt());
     System.out.println(s.nextInt());
     System.out.println(s.next());
     System.out.println(s.next());
     s.close();

2.2 常用方法

sc.hasNextLine() // 如果存在下一行则返回 true
sc.nextInt()   // 读取Int类型数据
sc.nextLong()  // 读取Long类型数据, 不同类型都有Float,Byte,Short,Boolean
sc.nextLine() //读取下一行

3. 输出控制

必须通过System.out.printf( "%f" )进行格式控制

4. Switch

switch(表达式){
    case 1:
    case 2:
        语句体1;
        break;
    case 3:
        语句体2;
        break;
    default:
        语句体3;
        break;
}

5. Random

import java.util.Random

常用方法：

Random ra = new Random();
ra.setSeed(种子值)
ra.nextInt()
ra.nextInt(正数边界值)

• 生成某范围的随机数

    Random r = new Random();
    public int getRandom(int min, int max){
        int num = r.nextInt(max);
        num = num  % (max-min+1) + min;
        return num;
    }

6. 堆内存，方法栈

• 堆内存： new出来的对象、数组都存储在堆内存
• 方法栈： 方法运行时使用内存，比如main方法运行时，进入方法栈中执行

6.1 多数组指向相同内存

7. 数组

• 静态初始化
  int[] a = {1,2,3,4}

• 动态初始化
  int[] a = new int[5]
  默认：
  int,long,byte,short: 0

float, double: 0.0

char: \u0000

boolean: false

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

• 数组拷贝

        int[] arr = new int[3]
        int[] arrcopy = Arrays.copyOf(arr, 2*arr.length); // 复制数组，而非引用
        int[] arrcopy1 = Arrays.copyofRange(arr, 1, arr.length-1) // 复制数组的一部分
        for(int i = 0; i< arrcopy.length; i++) arrcopy[i]+= 1; // 修改复制后数组
        for(int i = 0; i< arr.length; i++) arr[i]+= 2;  // 修改原数组
        System.out.println(Arrays.toString(arr));   // [2,2,2]
        System.out.println(Arrays.toString(arrcopy));  // [1,1,1,1,1,1] 两个数组不会互相影响，完全独立

• 数组排序
  Arrays.sort(arr)

• 数组填充
  Arrays.fill(arr, 10);

• 数组一致性对比
  Arrays.equals(arr1, arr2)

• 二维数组

        // 声明二维数组
        int[][] arr2 = {
                {1,2,3},
                {2,3,4},
                {3,4,5}
        };
        // 遍历二维数组输出的几种方式
        for(int i = 0; i < arr2.length; i++){
                System.out.println(Arrays.toString(arr2[i]));
        }
[1, 2, 3]
[2, 3, 4]
[3, 4, 5]        
        // 标准对二维数组操作
        for(int i = 0; i < arr2.length; i++){
            for( int j = 0; j < arr2[i].length; j++){
                System.out.print(arr2[i][j]);
            }
            System.out.println();
        }
123
234
345
        // 快速遍历读取
        for(int[] row: arr2)
            for(int e: row)
                System.out.print(e);
123234345
        // 转化为数组读取
        System.out.println(Arrays.deepToString(arr2));
[[1, 2, 3], [2, 3, 4], [3, 4, 5]]

• 二维数组的行互换

        int[] tmp = arr2[1];
        arr2[1] = arr2[2];
        arr2[2] = tmp;

• 不规则数组

        // 不规则数组声明
        int[][] arr3 = new int[5][];
        for(int i = 0; i < 5; i++){
            arr3[i] = new int[i+1];
        }
        // 赋值
        for(int i = 0; i < arr3.length; i++){
            for(int j = 0; j < arr3[i].length; j++){
                if(j == 0 | i==j){ arr3[i][j] = 1;}
                else arr3[i][j] = arr3[i-1][j] + arr3[i-1][j-1];
            }
        }
        // 遍历
        for(int i = 0; i < arr3.length; i++){
            System.out.println(Arrays.toString(arr3[i]));
        }
[1]
[1, 1]
[1, 2, 1]
[1, 3, 3, 1]
[1, 4, 6, 4, 1]

7. for循环

• for each不需要下标的遍历数组

    for(int e: arr) System.out.println(e);
    for(int i = 0; i < arr.length; ++i){
        System.out.println(arr[i]);
    }

或者直接通过Arrays.toString(arr)转换为字符串输出：System.out.println(Arrays.toString(arr)); —》 [0, 0, 0]

8. 数据类型转换

8.2 int,long,float,double,boolean,char,char[] —> String

String s = String.valueOf(10)
String s = String.valueOf(10.2)
String s = String.valueOf(true)

8. int,long,float,double,boolean,char,char[] —> String

Double d = 10.2; String ds = d.toString();
int i = 10; String is = i.toString();
Boolean b = true; String bs = b.toString();

8.1 String —> int

int i = Integer.parseInt("10")

8.2 String —> Double

Double d = Double.valueOf("10.2")

String —> char[]

String str="123456"; char[] c = str.toCharArray() ;

Double —> int

Double d = 10.6; int di = d.intValue();得到整数10，舍去小数位

Date <—> String

java.sql.Date day = TypeChange.stringToDate("2003-11-3");
String strday = TypeChange.dateToString(day);

String —> Integer, Long, Float, Double, Short, Byte

string->byte 
Byte static byte parseByte(String s)  
string->Short 
Short static Short parseShort(String s) 
String->Integer 
Integer static int parseInt(String s) 
String->Long 
Long static long parseLong(String s) 
String->Float 
Float static float parseFloat(String s) 
String->Double 
Double static double parseDouble(String s)

9. 各个数据类型默认值

所有的包装类默认值都为null