[Java知识库]第3章基本程序设计结构（java知识点笔记）

javac JDK;

jdk-->x.java--->x.class;

JRE-->x.class--->翻译给操作系统。

例如：命令javac Test.java就是按照上述操作顺序编译出Test.class；然后用Java Test翻译Test.class文件给操作系统

Java SE是最原始的Java功能；Java EE是Java用于网站方面的开发；JavaME是Java用于安卓方面的开发。

类（class）用大驼峰命名法，首字母大写，小驼峰命名法，首字母要小写，其他的大写常用语文件名、变量名和方法名。

数据类型：

整型

int 32bit；short 16bit；long 64bit；byte 8bit

取值范围

int：-2^31~2^31-1

short：-2^15~2^15-1

浮点型

float 类型的有效位是6、7位，有效位是从第一个不为0的数开始，往后的都是有效位

由此可以看出，float类型的数精度并不是很高。当data趋于0是精度越高，反之精度越低，呈现指数级下降。虽然int和float类型都占32位，但是不能说float类型的精度就比int类型高。

char-根据编码决定 Unicode/GBK 16bit UTF-8 16-32bit

boolean-32bit ----boolean类型有两个值TRUE和FALSE，用来判断逻辑条件，同时整型值和布尔值之间不可以相互转化。

进制在计算机中的编写形式：

int y1=ob1101010二进制；

inty1=074556 八进制；

int y3=oxad5659十六进制；

进制转换：

1、十进制转m进制，就是除m求余，直到商为0.

2、N进制1后面有几个0就是N^m：

int 456 = 256+128+64+8 =11101000；

float 1 : 8 : 23

??? 0 ? ???????? 00000000 ? ? ?? 00000000000000000000000

符号位??? ??????? 阶码 x ?????????????????????? 数值y

计算公式：float（2^(x-127)）*y

double 1:11:52 （2^(x-1024)）*y

所有的编码都是ASCII编码，ASCII编码在其他编码中数值是不变的，但是所占的位数是不同在ASCII中占8位，在Unicode中就占16位。

码点：是指一个编码表中某个字符对应的代码值

代码单元：存储单位16bit，每个字符用16位表示

高速缓存的基准单元是64B，每个缓存行都有一个主线相连。

在Java中声明的数据要大一点，增大boolean减少排队数据的个数，减少堵塞概率。

变量：

除了8大基本类型其余的都是引用类型，基本类型的数组，也是引用类型（基本类型和引用类型的区别在后面会写到）

常量：

在Java中利用final来指示常量，表示这个变量只能被赋值一次，一旦被赋值就无法修改；常量名使用全大写。

重点：final的作用

1、final m1=90；定义的常量，且不可以修改

2、final修饰的类不可被继承

3、final修饰的方法不可以被重写

4、final防止多程序下的指令重排序，保障现成的安全

使用Math类中的方法

1、Math.方法

2、在文件的开头加上

import static java.lang.Math.*;

就可以直接使用Math类中的方法。

常见的Math类中的方法：

?Math.sqrt() 根号

Math.pow(x,a);x^a

强制类型转换：

int x2=20000000000;
byte b1 =(byte)x2;

结果只会保留最右侧的位数，左侧的位数都会舍弃，导致精度大程度降低。

二进制移位：

int b=a<<3;//a*2^3
int c=b<<3;//b/2^3;

int c=a>b?10:20;//如果a>b成立c=10，否则c=20

字符串：

1、获取子串

substring（）方法

String aa="dashsjdhaus";
String b=aa.substring(2,4);//前闭后开[2,4)2、3

2、拼接

String expletive = "Expletive";
String PC13 = "deleted";
String message = expletive + PC13；

3、不可变字符串：

不能再原地址上修改，是因为原地址空间是固定的，如果后来的数据可能过大。修改完之后，原地址的数据就会被抛弃；实际上是被标记为无效，等下一次使用该地址时直接被覆盖。

4、检测字符串是否相等

引用类型==引用类型 表示两个引用类型，引用的地址是同一个地址的数据，是同一个就返回TRUE，不是返回FALSE

a、c为两个字符串（引用类型）a==c比较的是两个字符串所存储的地址是否相同，a.equals(c)是比较两个值是否相等。

使用equals()方法判断字符串是否相等

“hello”.equals("hello");
“hello”.equalslgnoreCase("hello");//不区分大小写

字符串的其他方法

char b1=a.charAt();//获取指定位置的字符

int b2=a.codePointAt();//获取指定字符的编码

boolean b3=a.startsWith("");//是否以该字母开头

boolean b3=a.endsWith("");//是否以该字母结尾

int indexOf("");//是否包含该字符串

st1 = st1.replace("ad","+");//替换

String[] arr = st1.split("");//分裂
for(String s:arr){
System.out.println(s);
}

int l1=st1.length();//记录字符长度

String a="";
	StringBuilder b =new StringBuilder();
	long start=System.currentTimeMillis();
	for(int i=0;i<10000;i++){
		//a +=1;
              b.append("" + i);                  
	}
     String b=b.toString();
	long endtime=System.currentTimeMillis();
	System.out.println("总花费时间是："+(endtime -
start)+"毫秒数");
b.append(""+i);//拼接功能

5、String,StringBuilder,StringBuffer的区别

String aa=new String aa();//一个字符占一页

StringBuilder aa=new StringBuilder aa();//一开始申请的空间很大，不需要换页存储，运行速度快。

StringBulider和StringBuffer分配空间的方式是一样的，不同的是StringBuffer是内部加锁，在多宣线程下是安全的,StringBuiilder在多线程下是不安全的。

输入输出：

1、读取输入

System in = new Scanner(System.in);

int num = in.nextInt();//输入参数，这句话在代码中出现几次，就会等待输入几次

import java.uitl.*;//这是运行Arrays类的前提
....
System.out.println("请输入数组大小");
Scanner aaa=new Scanner(System.in);
int num = aaa.nextInt();
int[] arr=new int[num];
System.ouy.println("请向数组中添加数据");
    for(int i=0;i<num;i++){
         arr[i]=aaa.nextInt();    
    
    }
System.out.println(Arrays.toString(arr));

2、格式化输出

System.out.print(x);直接输出x；

System.out.printf("%8.2f",x);打印出用8个字符的宽度和小数点等候两个字符的精度的x。

在printf中可以打印多个参数，

?Switch循环语句：

Scanner in =new Scanner(System.in);
int choice=in.nextInt();
Switch(choice)
{
    case 1:
      ....;
       break;  
    case 2:
      ....;
       break; 
    case 3:
      ....;
       break; 
    default :
        System.out.println();
        return;
}

每一个case要对应一个break否则就会直接执行下一个case，引发错误。

设计一个计算器

public class Test{ 
    public static void main(String[] aaaa){

        System.out.println("欢迎使用百望山计算器，请选择计算类型数字：");
        System.out.println("1-加法： 2-减法： 3-乘法： 4-除法：");
        System.out.println("请输入计算类型:");
        Scanner aa= new Scanner(System.in);
        int flagtype =aa.nextInt();
        switch(flagtype){
         case 1:
          System.out.println("您选择的是加法计算:");
        break;
        case 2:
          System.out.println("您选择的是减法计算:");
        break;
        case 3:
          System.out.println("您选择的是乘法法计算:");
        break;
        case 4:
          System.out.println("您选择的是除法法计算:");
          break;
        default:
          System.out.println("您选择的是非法计算，请重新开始:");
        break;
        }
         System.out.println("请输入要计算的两个数字:");
        int num1=aa.nextInt();
        int num2=aa.nextInt();
        System.out.println("新输入的两个数字是：" + num1 +","+num2);
        if(flagtype ==1){
                System.out.println("最终的计算结果是：" + (num1 + num2));
        }else if(flagtype ==2){
                System.out.println("最终的计算结果是：" + (num1 - num2));
        }else if(flagtype ==3){
                System.out.println("最终的计算结果是：" + (num1 * num2));
        }else {
                System.out.println("最终的计算结果是：" + (num1 / num2));
        }

        }
    }
}

for each 循环

for (variable : collection) statement

collectiom这一集合表达式必须是一个数组或者是一个实现Iterable接口的类对象
?

for(int x:arr)

        System.out.println(x);

大数值：

java.math包中有两个很有用的类BigInteger和BigDecima；BigInteger实现任意精度的整数运算；BigDecimal实现任意精度的浮点数运算。

使用静态的valueOf方法可以将普通的数值转换为大数值，

BigInteger a=BigInteger.valueOf(100);

BigInteger c=a.add(b);//c=a+b;

BigInteger d=c.multiply(b.add(BigInteger.valueOf(2)));//c*(b+2)

BigDecimal同BigInteger用法一样

数组：

1、匿名数组

new int[]{7,8,9};//初始化一个匿名数组

smallPrimes=new int[]{7,8,9}；

2、Arrays类的使用

import java.util.*;

?或者

引用类型数组，复制数组使用Arrays.copy();

算法中常使用的排序函数Arrays.sort();