Java核心技术总结一:Java的基本程序设计结构

---

一、注释

//      单行注释
/* */   多行注释
/** */  自动生成文档

二、数据类型

• 整型

    类型    存储需求    取值范围
    byte    1字节      -128 ~ 127
   short   2字节      -32768 ~ 32767
    int     4字节      -2147483648 ~ 2147483647
    long    8字节      -9223372036854775808 ~ 9223372036854775807

    补充:
    长整型整数有后缀L或l，十六进制有前缀0x或0X，八进制有前缀0
    jdk1.7以后，加上前缀0b或者0B就可以写成二进制数，如0B1001即为9
    jdk1.7以后，可以为数字加上下划线，使其更易读，如1_000_000即为100万
    Java没有任何无符号形式的byte、short、int、long类型

• 浮点类型

类型    存储需求    取值范围
float   4字节      大约±3.402 823 47E+38F(有效位数为6~7位)
double  8字节      大约为±1.797 693 134 862 315 70E+308(有效位数为15位)
   
补充:
float类型有后缀F或f，没有后缀F的浮点数值(如3.14)默认为double类型
浮点数不适用于无法接受舍入误差的金融计算，如2.0-1.1=0.8999999...
不是期望的0.9,如果在计算中不允许有误差，就应该使用BigDecimal类
 

• char类型

Java中的char类型占2字节，16位，其采用Unicode字符(ASCll码也包含在类)
常用的ASCll码:
0-9：48-57
A-Z：65-90
a-z: 97-122

• boolean类型

有两个值:true和false，用来判断逻辑条件。

补充：
整型值和布尔值不能进行相互转换
如if(x=0)，在C++中可以编译运行，其结果总为false，而java中不能通过编译，因为整数表达式x=0不能转换为布尔值

三、变量与常量

• 变量

变量比较简单，这里说下注意点:
1.变量声明后必须使用赋值语句对变量进行显式初始化，不能使用未初始化的变量
如 int a；System.out.println(a)；//错误，a未初始化
2.变量的声明尽可能靠近变量第一次使用的地方
3.jdk10以后，如果可以从变量的初始值推断出它的类型，
就不需要声明类型，只需要使用关键字var而无需知道类型
如 var number=12;//number为int类型；
   var name=“zhangsan”;//name为String类型

• 常量

1.java中，利用关键字final指示常量，final表示该变量一旦被赋值无法更改
2.习惯上，常量名使用全大写
3.如果希望某个常量可以在一个类的多个方法中使用，可以将其设置为类常量，
使用关键字static final进行设置(类常量定义于main方法的外部)

• 枚举类型

针对某个变量的取值只在一个有限的集合里，可以自定义枚举类型
如 
enum Size{SMALL,MEDIUM,LARGE};
Size s=Size.LARGE;

四、运算符

• 算术运算符

+、-、*、/，%
/运算需要注意，当参与/操作的两个操作数都是整数时，表示整数除法；否则，表示浮点除法，如15/2=7,15.0/2=7.5
注意：整数被0除将产生1个异常；浮点数被0除将得到无穷大或NaN结果

• 数学函数与常量

1.Math.sqrt(x)，计算x的平方根
2.Math.pow(x,a)，计算x的a次方，返回值为double类型
3.最接近π的常量：Math.PI;最接近e的常量：Math.E
说明:
1.只要在源文件顶部加上import static java.lang.Math.*；则使用Math类置的函数与常量不需要加Math
例如:
import static java.lang.Math.*;
public class test {
  public static void main(String[] args) {
      System.out.println(sqrt(PI));
  }
}
2.java中数学运算如果计算溢出，数学运算符只是返回一个错误结果而不做任何提示，
如:1000000000*3=-1294967295,因为int最大值才刚超过20亿，
此时可以采用Math.multiplyExact(1000000000,3)进行计算，它就会产生一个异常

• 数值类型之间的转换

1.合法转换:
byte->short->int->long(double)；char->int->long(double)；float->double
int-->float；long-->float；long-->double
->转换表示无信息丢失，-->表示可能有精度的丢失
如int n=123456789;float f=n;//f =1.2345679E8 ；这是因为123456789包含的位数比float类型所能够表示的位数多.
2.当用一个二元运算符连接两个值时(例如n+f)，先要将两个操作数转换为同一操作数，再进行计算。
规则如下:
两个操作数有一个为double类型,则另外一个转为double型
否则有一个为float类型,则另外一个转为float型
否则有一个为long类型,则另外一个转为long型
否则，两个操作数都将被转为int型

• 强制类型转换

上一节可以看到，在必要时int会自动转成double，但当需要将double转成int时，需要使用强制类型转换。
语法格式为:在圆括号中给想要转换的目标类型，后面紧跟待转换的变量名。
例如:double x=9.96；int y=(int)x;/y=9；
注意:
如果试图将一个数值从一种类型强制转换为另一种类型，而又超出了目标类型的表示范围，结果就会截断成一个完全不同的值，例如,(byte)300的实际值为44

• 特殊运算符

1.结合赋值和运算符 (+=,-=;*=;/=,%=...)
如x+=4；等价于x=x+4;
注意:如果x为一个int型，则x+=3.5，即x=(int)(x+3.5）,发生强制类型转换
2.自增减运算符（n++,++n,n--,--n）
在表达式中，前缀会先进行±1操作，而后缀会先使用变量原来的值
如 int m=4;int n=3*m++;//n=12;m=5
   int m=4;int n=3*++m;//n=15;m=5
3.关系和boolean运算符
- 检测相等性，使用==，如3==7的值为false
检测不相等，使用!=，如3!=7的值为true
还有常用的<，>，<=,>=
2.expression1&& expression2:
逻辑与:当两个表达式都为true结果为true，否则为false
expression1|| expression2
逻辑或:当两个表达式只要有一个为true结果为true，否则为false
注意:逻辑与和或都按照短路方法求值，即如果expression1可以确定结果，expression2不进行计算。
3.condition?expression:expression2
当condition为true，结果就为expression1，否则为expression2

• 位运算

1.&(and),|(or),^(xor),~(not)
如3&7=7，(011&111=3)
注意&，|也可用在布尔值上，此时其与&&,||相似，只不过不采用短路方法计算。
2.左移<<,右移>>
如1<<3结果为8
注意右移时如果不够移，则结果为0，如1>>2结果为0;
注意:移位操作符的右操作数要完成模32的运算(如果左操作数为long型，则为模64)，
例如1<<35等价于1<<3

• 括号与运算符级别

优先级           运算符                           结合性
1 	            ()、[]、{}	                    从左向右
2	            !、+、-、~、++、--               从右向左
3           	*、/、%	                        从左向右
4	            +、-	                        从左向右
5	            «、»、>>>	                    从左向右
6        	    <、<=、>、>=、instanceof    	    从左向右
7               ==、!=	                        从左向右
8	            &	                            从左向右
9           	^	                            从左向右
10	            |	                            从左向右
11	            &&	                            从左向右
12	            ||	                            从左向右
13	            ?:	                            从右向左
14	            =、+=、-=、*=、/=、&=、|=、^=     从右向左
                、~=、«=、»=、>>>=	

五、字符串

• 子串

String的substring方法可以从一个较大的字符串提取出一个子串。例如:
Stirng father="hello";
String son=father.substring(0,3)； //son即为"he"
substring第二个参数是不想复制的第一个位置，本例从0到2复制
substring的工作方式有一个优点;容易计算子串的长度。s.substring(a,b)的长度为b-a

• 拼接

1.java允许使用+连接(拼接)两个字符串
当将一个字符串与一个非字符串的值进行拼接时，后者会转换成字符串。
如 int num=2020；String year=“this year is”+num;//year为字符串"this year is 2020".
2.jdk11中，提供了repeat方法
Stirng repeated="Java".repeat(3);//repeated为字符串"JavaJavaJava"

• 不可变字符串

由于不能修改java字符串中的单个字符，所以在java文档中将String类对象称为是
不可变的，如 String a="hello",“hello”这个值不可以修改，但是可以修改字
符串变量a，使得其引用另外一个字符串，如 a=“hi”。
不可变字符串有一个优点:编译器可以让字符串共享:可以想象将各种字符串存放在公
共的存储池中。字符串变量指向存储池中相应的位置。如果复制一个字符串变量，原
始字符串与复制的字符串共享相同的字符。

• 检测字符串是否相等

1.可以使用equals方法检测连个字符串是否相等
s.equals(t):如果字符串s和字符串t相等，返回true，否则返回false。
一定不要用==运算符检测两个字符串是否相等(该运算符只能确定两个字符串是否存
放在同一个位置，但完全有可能将内容相同的多个字符串副本放置在不同的位置)

• 空串与Null串

1.空串""是长度为0的字符串(可以使用sr.length()==0或者str.equals(“”))
检查字符串是否为空
2.String可以存放一个特殊的值->nul，要检查一个字符串是否为null,要使用
str==null进行判断。
有时需要检查一个字符串既不是null也不是空串，可以使用以下条件进行判断:
str!=null&&ste.length()!=0
注意:两者顺序不能颠倒，如果在一个null值上调用方法，会出现错误
所有上文的equals方法，如果字符串a不为null，则应该使用a.equals(b)来判断
a和b是否相等，因为b可能存在为null的情况。

• 构建字符串

每次拼接字符串时，都会构建一个新的Sring对象，既耗时有浪费空间，使用
StringBuilder类可以避免这个问题的发生。
例如;
       StringBuilder sb=new StringBuilder();
        sb.append("hello");
        sb.append("world");
        String s= sb.toString();
        //通过这种方式创建了字符串s，其值为"helloworld”。
扩展: StringBuilder在jdk1.5引入，其前身是 StringBuffer，效率
比 StringBuilder低，但是它允许采用多线程方式添加或删除字符。而 
StringBuilder不能，如果所有字符串编辑操作都在单线程中执行，则
应该使用 StringBuilder。

六、输入与输出

• 读取输入

想要通过控制台进行输入，需要构造一个与“标准输入流”System.in关联的
Scanner对象。下面例子展示如何从控制台输入并获取值。
 	Scanner sc=new Scanner(System.in);
    System.out.println("please input your name");
    String name=sc.nextLine();//获取控制台输入
    Scanner不只有nextLine方法，还有nextInt，next等多种方法，详见jdkAPI

• 格式化输出

jdk1.5沿用了C语言函数库的printf方法
例如
double x=1.12345678;
System.out.printf("%8.2f",x);
//输出为    1.12
//这包括8个字符，其中精度为小数点后2个字符，所以会打印前导空格和4个字符。

• 文件输入与输出

读取文件:
Scanner in = new Scanner(Path.of("myfile.txt"), StandardCharsets.UTF_8);
写入文件:
PrintWriter out = new PrintWriter("myfile.txt", StandardCharsets.UTF_8);
注意:如果一个不存在的文件构造一个Scanner或者一个无法创建的文件名构造一个PrintWriter,就会产生一个异常。

七、控制流程

• 块作用域

块(即复合语句)是指有若干条java语句组成的语句，并用一对大括号括起来。块定义
了变量的作用域。一个块可以嵌套在另一个块中。
如:
    public static void main(String[] args) {
        int n;
        //...
        {
            int k;
            //...
        }
    }
但不能在嵌套的两个块中声明相同的变量。
如：
    //无法通过编译
    public static void main(String[] args) {
        int n;
        //...
        {
            int n;
            int k;
            //...
        }
    }

• 条件语句

           //举例说明
            int a=1;
            int b=2;
            if(a>b){
               System.out.println("a");
            } //无输出

           if(a>b){
            System.out.println("a");
            }else{
            System.out.println("b");
            }//输出b

             if(a>b){
            System.out.println("a");
             }else if(a==b){
            System.out.println("==");
             }else{
            System.out.println("b");
            }//输出b

• 循环

     /*
            1.while循环
            while(condition){
            statement
            }
            当condition为true，执行statement,为false，退出循环
           该循环至少执行0次
           2.do-while循环
            do{
            statement
            }while(condition)
            该循环先执行statement，再检测循环条件，为true继续执行，否则退出循环
            该循环至少执行一次
         */
               int num=1;
               int sum=0;
               while(num<=5){
                   sum+=num;
                   num++;
               }
                System.out.println(sum);//输出15
                //此时num=6;
               do {
                   sum+=num;
                   num++;
               } while(num<=5);
                System.out.println(sum);//输出21

• 确定循环

 /*
          for循环:
          第一部分通常是对计数器初始化，如本例的int j=0；
          第二部分给出每新一轮循环执行前要检查的条件，如果为false，退出，否则继续，如本例的j<=5
          第三部分指定如何更新计算器，如本例的j++
          注意:检测两个浮点数是否相等需要格外小心，下面的for循环可能永远不会结束
          for(double x=0;x!-10;x+=0.1)...
          这是因为舍入的误差，可能永远达不到精确的最终值
         */
        int sum=0;
        for (int j = 0; j <=5 ; j++) {
            sum+=j;
        }
        System.out.println(sum);//输出15 ,0+1+2+3+4+5

• 多重选择：switch语句

   /*
         switch语句语法如下:
         switch(expression){
         case value :
         //语句
         break; //可选
         case value :
         //语句
         break; //可选
         //你可以有任意数量的case语句
         default : //可选
         //语句
         }
         1.当expression的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句。
         2.当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。
         如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。
         3.switch 语句可以包含一个 default 分支，该分支一般是 switch 语句的最后一个分支
         default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。
         */
      int choice= (int)(Math.random()*4);
       switch (choice){
           case 0:
               System.out.println("0");
               break;
           case 1:
               System.out.println("1");
               break;
           case 2:
               System.out.println("2");
               break;
           default:
               System.out.println("3");
       }//输出choice的值

• 中断控制流程的语句

        /*
           1.continue 语句语句用来结束当前循环，并进入下一次循环，即仅仅这一次循环结束了，
           不是所有循环结束了，后边的循环依旧进行
           2. break 语句语句用来结束循环，所有循环结束
           下面用for循环举例，while，do-while循环同理
         */
        int sum=0;
        for (int i = 0; i <=5 ; i++) {
            if(i==1){
                continue;
            }
            sum+=i;
        }
        System.out.println(sum);//输出14，因为只有i=1时没有执行sum+=i;
        sum=0;
        for (int i = 0; i <=5 ; i++) {
            if(i==1){
                break;
            }
            sum+=i;
        }
        System.out.println(sum);//输出0，因为i=1时退出循环

八、大数

如果基本的整数和浮点数精度不能够满足需求，
可以使用java.math包中两个很有用的类，BigInteger和BigDecimal，
BigInteger类实现任意精度的整数计算
BigDecimal类实现任意精度的浮点数计算
1.使用静态的valueof方法可以将普通数值转换为大数
 BigInteger a=BigInteger.valueOf(100);
2.对于更大的数，可以使用一个带字符串参数的构造器:
 BigInteger bigInteger = new BigInteger("4632879378293728937298378983793728937812937812");
3.不能使用熟悉的算术运算符处理大数(如+和*)，而是使用大数的add和multipy方法
 BigInteger c=a.add(b);//c=a+b
 BigInteger d=c.multiply(b);//d=c*b

九、数组

• 数组声明、访问

       //声明数组
        int []a;//也可以写成int a[]
        // 将数组a初始化
        a=new int[100]; //两步可以连起来，写成int []a=new int[100]，此时数组a里所有元素值均为0
        int []b={2,3,4,5};//创建数组对象并提供初始值的简写形式，该数组长度为4
        int []c=new int[0];//在java中。数组长度可以为0,但其不等同与null
        int len=a.length;//len为100，即获取a数组的长度
        //访问数组元素,如a数组的下标从0-99，a[100]，会引发"array index out of bounds"异常
        for (int i = 0; i <a.length ; i++) {
            a[i]=i;//给a[i]赋值，
        }

• for each 循环

        /*
        增强for循环
        for(variable:collection){
            steatment
        }
        variable为保存在collection里的元素(按顺序排列)，collection必须是一个数组或者实现Iterable接口的对象
        for each循环遍历的是数组中的每个元素，而不是下标值
         */
         //打印数组中所有元素值
        for (int element: a){
            System.out.println(element);//依次输出0-99
        }
        //更简单的方法为Arrays.toStirng(a);

• 数组拷贝

   //在java中，允许将一个数组变量拷贝到另一个数组变量。这时两个变量将引用同一个数组
         int []aa=a;
         aa[5]=12;//此时a[5]=12;
        //如果希望将一个数组的所有值拷贝到一个新的数组中，就使用Arrays类的copyOf方法
        //第二个参数时新数组的长度，可以大于或小于拷贝的数组长度，如果大于数组长度，则多出的初始值为0
        //(boolean数组初始值为false)，小于数组长度，则只拷贝前面的值
        int []copyA= Arrays.copyOf(a,a.length);
        copyA[6]=16;//此时a[6]=6,不发生变化

• 数组排序

  //想要对数值型数组进行排序,可以使用Arrays类中的sort方法，这个方法使用了优化的快速排序算法，效率较高
        int []sort={4,1,3,2};
        Arrays.sort(sort);//现在sort数组的顺序为{1,2,3,4}
 //如果对字符串数组使用Arrays，sort方法排序,则回按照字典顺序进行排序

• 二维数组

        //二维数组
        //声明二维数组
        int [][]m;
        //将数组m进行初始化
        m=new int[10][10];
        //遍历二维数组并赋值
        for (int i = 0; i <m.length ; i++) {//m.length，数组行的个数
            for (int j = 0; j <m[i].length ; j++) {//m[i]length，数组第i行元素个数
                m[i][j]=i*10+j;//对数组进行赋值
            }
        }
        //输出二维数组的元素值
        //方法1
        for (int i = 0; i <m.length ; i++) {//m.length，数组行的个数
            for (int j = 0; j <m[i].length ; j++) {//m[i]length，数组第i行元素个数
                System.out.println(m[i][j]);
            }
        }
        //方法2
        for (int []row:m){
            for (int value:row){
                System.out.println(value);
            }
        }