三、Java的基本程序设计结构

末蓝、 2022-03-22 05:45 273阅读 0赞

**目录**

一、数据类型

Int

short

long

byte

float

double

char

boolean

二、变量

三、运算符

四、字符串

不可变字符串：编译器可以让字符串共享

字符串相关操作：

码点和代码单元

构建字符串

五、输入输出

格式化输出

文件输入与输出

六、控制流程

七、大数值

八、数组

数组声明，初始化：

for each循环

打印数组数值

数组拷贝

命令行参数

数组排序

多维数组

不规则数组

--------------------

# **一、数据类型** #

>  *  **类名：必须是字母开头，后面可以跟字母和数字的任意组合**
>  *  **如果main方法正常退出，那么Java应用程序的退出代码为0，表示成功运行了程序。如果希望在终止时返回其它的代码，那就需要调用System.exit方法。**

--------------------

## **Int   4字节** ##

**前缀加上0b就可以写二进制数，十六进制0x，八进制x**

## **short  2字节** ##

## **long  8字节** ##

**后缀L或l    **

## **byte   1字节** ##

**1个字节**

## **float   4字节** ##

**  后缀f或F**

## **double   8字节** ##

**默认，大部分程序使用**

*  **注意：Java没有任何无符号形式的整形**
 *  **可以用十六进制表示浮点数值。例如0.125可以表示成0x1.0p-3.尾数用十六进制，指数采用十进制**
 *  **三个特殊的浮点数 **
 *  **浮点数值不适用于无法接受舍入误差的金融计算中。如果在数值计算中不允许有任何误差，就应该使用BigDecimal.**

double a= Double.POSITIVE_INFINITY;  //正无穷大
    	  double b=Double.NEGATIVE_INFINITY;   //负无穷大
    	  double c=Double.NaN;   //不是一个数字
    	  //检测一个特定值是否等于Double.NaN
    	  // if(c==Double.NaN)  这样不对
    	  //这样做
    	  if(Double.isNaN(c)) {}

## **char** ##

**       所有转义序列可以出现在加引号的字符字面量或字符串中，一定要注意注释中的\\u,也会起作用的。\\u可以出现在加引号的字符常量和字符串之外，默认Unicode编码**  
**  char在设计之初的时候被用来存储字符，可是世界上有那么多字符，如果有1个字节，那么就意味着只能存储256中，显然不合适，而如果有两个字节，那么就可以存储65536种。这个数量符合大多数国家的语言字符的个数。于是java团队默认使用unicode作为编码，一个char作为2个字节来存储。   
  这里就有两个问题了?   
    1. java的char一定会有两个字节吗?   
    2. 中文字符可以存储在char里面吗?   
  先来回答第一个问题。char一定是两个字节吗?不是的，这个跟我们选用的字符编码有关，如果采用”ISO-8859-1”编码，那么一个char只会有一个字节。如果采用”UTF-8”或者“GB2312”、“GBK”等编码格式呢?这几种编码格式采用的是动态长度的，如果是英文字符，大家都是一个字节。如果是中文，”UTF-8”是三个字节，而”GBK”和”GB2312”是两个字节。而对于”unicode”而言，无论如何都是两个字节。   
  然后再回答第二个问题，对于一个char如果用”ISO-8859-1”来存储的话，肯定无法存储一个中文，而对于”UTF-8”、“GB2312”、“GBK”而言大多数中文字符是可以存储的。**

## **boolean** ##

**整型值和布尔值之间不能进行相互转换**

--------------------

# **二、变量** #

**   变量名必须是一个以字母开头并由字母和数字组成的序列。Java中字母和数字的范围更大。字母包括’a'-'z','A'-'Z','\_','$'或在某种语言中表示字母中的任何Unicode字符。**

**   在Java中不区分变量的声明和定义。**

**  使用final指示常量，每个常量只能被赋值一次。一但被赋值之后，就不能再更改了。static final设置一个类常量。**

--------------------

# **三、运算符** #

**   整数被0除将会产生一个异常， 而浮点数被0除将会得到无穷大或NaN结果。**

**   对于使用strictfp关键字标记的方法必须使用严格的浮点计算来生成可再生的结果。可以标记类和函数。StrictMath在所有平台上得到一样的结果。**

**   数值之间的转换（静态）：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70][]

**   强制类型转换：如果试图将一个数值从一个类型强制转换成为另一种类型， 而又超出了目标类型的表示范围， 结果将会截断成一个完全不同的值。**

**   结合赋值和运算符：如果运算符得到一个值， 其类型与左侧操作数的类型不同，将会发生强制类型转换。**

**   关系运算符：&&和||运算符是按照短路的方法求值的：如果第一个操作数已经能够确定表达式的值， 第二个操作数就不必计算了。可以利用这一点来避免错误。**

**   位运算符：包括&  |  ^  ~  <<  >>  >>>(用0填充高位）。应用在布尔值上时，&和|运算符也会得到一个布尔值，不过&和|运算符不采用‘短路’方式。移位运算符的右操作数将要完成模32的运算。**

**  枚举类型：包括有限个命名的值。Size类型的变量只能存储这个类型声明给定的某个枚举值，或者null值**

public class Welcome
    {
       enum Size{a,b,c};
       public static void main(String[] args)
       {
    	  Size s=Size.b;
    	  System.out.println(s);
       }
    }

--------------------

# **四、字符串** #

**  java字符串就是Unicode字符序列**

### **不可变字符串：编译器可以让字符串共享** ###

**  各种字符串在公共存储池中。字符串变量指向存储池中相应的位置。如果复制一个字符串变量，原始字符串与复制的字符串共享相同的字符。**

**  Java字符串大致类似char指针**

**   greeting=“World”不会造成内存泄漏，Java自动进行垃圾回收**

**  **

### ** 字符串相关操作：** ###

//提取子串
    	  String str="Hello";
    	  String str2=" World";
    	  String substr=str.substring(0,3);
    	  System.out.println(substr);
    	  //拼接,字符串与一个非字符串的值进行拼接时，后者被转换成字符串
    	  String str3=str+str2;
    	  System.out.println(str3);
    	  //将多个字符串用一个定界符分隔
    	  String joinStr=String.join("/", "Hello","wprld");
    	  System.out.println(joinStr);
    	  //比较两个字符串是否相等&忽略大小写
    	  //一定不要用==检测两个字符串是否相等，只能检测两个字符串是否放置在一个位置上。只有字符串
    	  //常量是共享的，+和substring产生的结果不是共享的
    	  if(str.equals("Hello")) {}
    	  if(str.equalsIgnoreCase("Hello")) {}

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 2][]

**判断空串和Null串**

String str="";
    	  if(str.length()==0) {}
    	  if(str.equals("")) {}
    	  if(str==null) {

### ** 码点和代码单元** ###

**遍历字符串，依次查看每个码点：**

int[] codePoints=str.codePoints().toArray();
    	  String s=new String(codePoints,0,codePoints.length);
    	  System.out.println(s);

**得到第i个码点**

String str="Hello";
    	  int a=str.codePointCount(0,str.length());
    	  int index=str.offsetByCodePoints(0,2);
    	  int cp=str.codePointAt(index);

### **构建字符串** ###

**  由较短的字符串构建字符串，使用StringBuider类**

StringBuilder builder=new StringBuilder();
    	   builder.append("sh");
    	   builder.append('a');
    	   String str=new String(builder);
    	   String st=builder.toString();

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 3][]

--------------------

# **五、输入输出** #

Scanner scan=new Scanner(System.in);
    	   int a=scan.nextInt();
    	   System.out.println(a);
          
    	   //解决密码不可见问题，=。
              //为了安全起见，返回的密码存放在一维字符数组中，而不是字符串中，在对密码进行处理后，应该
               //马上用一个填充元素覆盖数组元素。
               //采用Console对象处理输入不如采用Scanner方便。每次只能读取一行输入，而没有读入一个单词
               //或一个数值的方法。
    	   Console console=System.console();
    	   String u=console.readLine("What's your name?");
    	   System.out.println(u);
    	   char[] p=console.readPassword("pass");
    	   System.out.println(p);

### **格式化输出** ###

**可以用s转换符格式化任意的对象。对于任意实现了Formattable接口的对象都将调用formatTo方法，否则调用toString方法。**

**  System.out.print(x)默认将x对应类型所允许的最大非0数字位数打印输出到x**

**  沿用printf方法实现格式化输出**

System.out.printf("%8.2f%n",10000.0/3.0);
    	   System.out.printf("%,(.2f%n",-10000.0/3.0);
    	   System.out.printf("%1$tB %1$te, %1$tY",new Date());

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 4][]

**![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 5][]**

**![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 6][]**

### **文件输入与输出** ###

String a=System.getProperty("user.dir");
    	   System.out.println(a);
    	   Scanner in=new Scanner(new File("a.txt"));
    	   Scanner inn=new Scanner(Paths.get("a.txt"));
    	   System.out.println(in.nextLine());
    	   System.out.println(inn.nextLine());
    	   PrintWriter ou=new PrintWriter(new File("b.txt"));
    	   ou.write("我爱你世界");
    	   ou.close();

**在PrintWriter流没关闭时，缓冲区没有刷新，文件写入失败**

**![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 7][]**

# **六、控制流程** #

**   不能在嵌套的两个块中声明同名的变量，无法通过编译**

**  else字句与最邻近的if构成一组**

![20190215191114357.JPG][]

**  Switch 的case标签可以是：**

*  **类型为char,byte,short,int的常量表达式**
 *  **枚举常量**
 *  **字符串字面量**

**当在switch语句中使用枚举常量时，不必在每个标签中声明枚举名**

**带标签的break（还有带标签的continue），只能跳出语句块，不能跳进语句块。标签可以用到任何语句中，甚至可以用到if语句或者块语句中。**

a:
    	   for(int x=0;x<=5;x+=1) {
    		   System.out.println("lala");
    		   break a;
    	   }

**continue语句将控制转义到最内层循环的首部，如果continue语句用于for循环中，就可以跳到for循环的“更新”部分**

# **七、大数值** #

**java.math包里包括BigInteger——实现任意精度的整数运算和BigDecimal——任意精度的浮点数运算.**

Scanner in = new Scanner(System.in);
    
          System.out.print("How many numbers do you need to draw? ");
          int k = in.nextInt();
    
          System.out.print("What is the highest number you can draw? ");
          int n = in.nextInt();
    
          /*
           * compute binomial coefficient n*(n-1)*(n-2)*...*(n-k+1)/(1*2*3*...*k)
           */
    
          BigInteger lotteryOdds = BigInteger.valueOf(1);
    
          for (int i = 1; i <= k; i++)
             lotteryOdds = lotteryOdds.multiply(BigInteger.valueOf(n - i + 1)).divide(
                   BigInteger.valueOf(i));
    
          System.out.println("Your odds are 1 in " + lotteryOdds + ". Good luck!");

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 8][]

# **八、数组** #

### **数组声明，初始化：** ###

int n=5;
          int a[]=new int[n];
          int[] b;
          //匿名数组
          a=new int[]{1,2,3,4,5};

**  创建一个数字数组时，所有元素都初始化为0。boolean数组的元素会初始化为false。对象数组中的元素则初始化为一个特殊值null，这表示元素还未存放任何对象。**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 9][]

### **for each循环** ###

int a[]= {1,2,3,4,5};
    	   for(int b:a) {
    		   System.out.println(b);
    	   }

**a这一集合表达式必须是一个数组或则是一个实现了Iterable接口的类对象（例如ArrayList）**

### **打印数组数值** ###

System.out.println(Arrays.toString(a));

**这些元素被放置在括号内，并用逗号分割，例如，【2，3，7，11，13】。**

### **数组拷贝** ###

**  在Java中，允许将一个数组变量拷贝给另一个数组变量。这时，两个变量将引用同一个数组**

int[] a= {1,2,3,4,5};
    	   int[] luckyNumbers=a;

**如果希望将一个数组的所有值拷贝到另一个新的数组中去，使用Arrays类的copyOf方法，第二个参数是新数组的大小，这个方法通常用来增加数组的大小**

int[] a= {1,2,3,4,5};
    	   a=Arrays.copyOf(a, 6);

** **

### **命令行参数** ###

public static void main(String[] args)
    {
    	   if(args.length==0||args[0].equals("-h")) {
    		   System.out.println("Hello, ");
    	   }
    	   else if(args[0].equals("-g")) {
    		   System.out.println("Goodbye, ");
    	   }
    	   for(int i=1;i<args.length;i++) {
    		   System.out.println(" "+args[i]);
    	   }
    }

**在Java应用程序的main方法中，程序名并没有存储在args数组中。例如，执行java a -h world,args\[0\]是-h**

**输出Goodbye,**

**world**

### **数组排序** ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 10][]

### **多维数组** ###

**声明，遍历**

double[][] a=new double[2][2];
    	   double[][] b= {
    			   {
    				   1,1
    			   },
    			   {
    				   2,2
    			   }
    	   };
    	   for(double[] s:b) {
    		   for(double k:s) {
    			   System.out.println(k);
    		   }
    	   }

**快速遍历**

System.out.println(Arrays.deepToString(b));

**Math.random**方法将返回一个0到1之间，用n乘以这个数，将可以得到从0到n-1之间的随机数。

### **不规则数组** ###

public class LotteryArray
    {
       public static void main(String[] args)
       {
          final int NMAX = 10;
    
          // allocate triangular array
          int[][] odds = new int[NMAX + 1][];
          for (int n = 0; n <= NMAX; n++)
             odds[n] = new int[n + 1];
          // fill triangular array
          for (int n = 0; n < odds.length; n++)
             for (int k = 0; k < odds[n].length; k++)
             {
                /*
                 * compute binomial coefficient n*(n-1)*(n-2)*...*(n-k+1)/(1*2*3*...*k)
                 */
                int lotteryOdds = 1;
                for (int i = 1; i <= k; i++)
                   lotteryOdds = lotteryOdds * (n - i + 1) / i;
    
                odds[n][k] = lotteryOdds;
             }
    
          // print triangular array
          for (int[] row : odds)
          {
             for (int odd : row)
                System.out.printf("%4d", odd);
             System.out.println();
          }
       }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 11][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70]: /images/20220322/ed7729987a6e4091a579f16f7dc845fa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 1]: /images/20220322/826738ee1dfc40bf957afe585d2cf6f1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 2]: /images/20220322/17383be2aa96447992071abde53b9c43.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 3]: /images/20220322/c91d6843706f4662bea6c563d950e516.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 4]: /images/20220322/533c4da2f2c04ab6a71ab58385b87da7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 5]: /images/20220322/1e8fe30d1ba14ecdb0083501a32bcff7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 6]: /images/20220322/41a97363bf764a3e81dbb94352a92646.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 7]: /images/20220322/e55c9c84baff407bb7adc5584c7dd000.png
[20190215191114357.JPG]: /images/20220322/c4e8e495fbc9460590696f09e4762490.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 8]: /images/20220322/e4ccd6da42a1440fa301a268de784ffa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 9]: /images/20220322/7937fdfb99714dc1b7e8056df2d59464.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 10]: /images/20220322/e7c10b11560d4106aed7f7b248794dd9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 11]: /images/20220322/32bf5e0f9a8141ec9abd0f010f4179f9.png