Java基础知识（一）

1、JAVA的环境配置

    java语言衍生自C++，1995年Sun公司发布的，是由詹姆斯高斯林所带领的团队在开发设计出来的语言，在这之前被称之为Oak(橡树)。截止今天，jdk已经发展到了jdk8。

    jdk：java开发工具包；jre：java运行环境；jvm：java虚拟机。

    jdk中包含了jre，而jvm又包含在jre中，所以，java的环境配置只需要安装jdk即可，访问oracle官网。

    安装好jdk后，需要配置环境变量：计算机—属性—高级系统设置—环境变量—系统变量，在path中添加jdk的bin文件夹路径。

    验证是否安装成功，开始，运行，输入cmd，确定，输入 javac 或 java -version。

2、编写小程序的步骤

     第一步：编写.java源文件，public class HelloWorld{}  class后面的名字必须与源文件的名字一致，而且首字母必须大写。
     第二步：编译，将.java文件编译成.class文件。在命令提示符中运行：javac  文件名.java。
     第三步：运行，在jvm上运行.class文件。在命令提示符中运行： java  文件名。

     注释：包括单行注释 / /，多行注释 /* */，文档注释 /** */。注释是为了解释所编写的代码含义，可以帮助程序员理解程序，但是不会被jvm当成代码运行

3、Java数据类型及其转换

    八大基本数据类型：
1.整数类型：byte short int long
2.浮点数类型：float double
3.字符类型(无符号整数类型)：char

4.布尔类型：boolean

    类型转换
1.自动转换
从小类型到大类型赋值，会自动转换
byte->short/char->int->long->float->double
2.强制转换
从大类型到小类型赋值，需要强制转换

格式：小类型名  变量名 = (小类型名)

4、变量

    在内存中开辟的一个存储空间，用来存储数据。
变量名的命名规则：
1.由字母，数字，下划线和$组成，但是数字不能开头
2.见名知意，驼峰命名法，不建议使用汉字
3.不能使用java中的关键字
变量的使用规则：
1.在使用之前必须先声明和初始化
2.变量可以重复赋值，必须是同一个类型

3.在一个作用域中，变量名不可以重复声明

5、运算符

    字符串(String)拼接符号： +
值的特点：是用双引号引起来的
在+前后，只要有一个是字符串类型，那么就做拼接操作，结果还是字符串类型  
算数运算符：
+，-，*，/,%,++，--
在运算时，当参与运算的变量，是byte,short,char,int时，运算结果就是int类型
%：取模，取余。在做除法运算时，商几，余几，结果时取余数部分
当++/--在变量前时，先自增运算，然后再把新值给表达式

当++/--在变量后时，先把变量的值给表达式，然后变量再自增

逻辑运算符
与：&&  &       或：||  | 非: !
规则：与运算,一假则假，全真为真
           或运算,一真则真，全假为假
           非运算，非假即真，非真即假
& | 单个符号的与或运算：前后两个条件都进行判断

&& ||,又叫短路运算符，当第一个条件就能确定整个结果时，不判断第二个条件

三目运算符(三元运算符)
格式：   boolean表达式? 值1:值2;
翻译： 如果条件成立，结果为值1，否则，结果为值2

  值1和值2必须是同一类型

6、Scanner扫描类型，Math数学类型

Scanner 扫描类型:开启键盘输入功能，将数据扫描进程序中

1.导包    import java.util.Scanner;
2.创建扫描类对象  Scanner scan = new Scanner(System.in);
3.调用方法进行扫描数据 int num = scan.nextInt();
阻塞效果,当没有扫描到数据时，程序被阻塞住不动，扫描到数据，并且回车表示扫描结束，
scan.nextDouble();可以扫描小数
scan.next()/nextLine();扫描的是字符串类型
 Math：数学类型  

Math.random();作用是随机产生一个[0,1)范围内的一个小数

7、程序运行结构之循环

循环结构：
当重复执行一些相同的代码逻辑或者相似的代码逻辑时，
就需要使用循环结构
循环三要素：
  1：循环变量的初始化
2：循环条件

3: 循环变量的改变----变量向着循环结束的方向改变

第一种循环结构：

while循环结构

while(boolean表达式){
要循环执行的内容
}
int i =0;//循环变量的初始化
    while(true){
System.out.println("你是好人");
i++;
  }
    System.out.println("over");
break; 
打断，毁掉的意思，break可以打断循环结构,执行循环结构后面的代码

第二种循环结构：
do{
循环体
}while(boolean表达式);


while与do-while的区别：
do-while:会先执行一次循环体，然后判断条件，

while:先判断条件，当条件为true时，执行循环体

第三种循环结构：
for循环
for(循环变量的声明和初始化;循环条件;循环变量变){
循环体

}

7、程序运行结构之分支

 if(boolean表达式){
  //表达式的结果为true时，执行
  }else if(boolean表达式){
  //表达式的结果为true时，执行
  }else if(boolean表达式){
  //表达式的结果为true时，执行
  }else{
  
  }
 switch语句
 格式：
switch(整数表达式){
case 值1：---------;
case 值2：---------;break;
……………………………………
default:--------;
}
整数表达式：结果类型只能是 byte short char int 

8、数组

    数组：一组相同类型的数据
数组的初始化：
静态初始化：int[]  arr = {1,2,3,4,5};
动态初始化：
int[]  arr1 = new int[5];//{0,0,0,0,0}
int[]  arr2 = new int[]{1,2,3,4,5}; 
数组的长度：         变量名.length;

数组的下标(索引)：从0到length-1

多维数组的初始化
静态初始化：
        int[][] arr = {{1,2,3},{2,3},{1,2,3,4},{1,2,3,4,5}};
动态初始化：只需要规定最外面的数组的长度
    int[][] arr = new int[3][];
    int[][] arr;
    arr = new int[][]{{1,2,3},{1,2}};

int[][][] arr = {{{1,2},{1,2,3}},{{1,2}}};

元素的访问:
元素的下标：从左到右，从0开始到length-1;
通过下标进行访问：变量名[下标]

reg:  int[]  ar = {1,2,3,4,5}

元素：就是数组中存的数据
长度：创建出来的数组长度都是固定的，不可变
变量名.length;

元素类型   变量= 变量名[下标]

整型数组：默认值0
浮点数类型：默认值0.9
字符类型：默认值'\u0000'
boolean类型：默认值false
引用类型：  默认值null
数组的遍历：从头到尾挨个查看
for(int i=0;i<5;i++){
System.out.println(a1[i]);
}
// 创建int数组arr，存入1,3,5,6,7,8
// 使用for循环进行遍历
int[] arr = {1,3,5,6,7,8};
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);

}

二维数组的遍历
   for(int i=0;i<arr.length;i++){
          int[] v = arr[i];//arr数组里的元素v是一个数组
          for(int j = 0;j<v.length;j++){
  System.out.print(v[j]+" ");
  }
  System.out.println();

   }

Arrays:数组工具类型
  Arrays.toString(数组变量名);
  导包：import java.util.Arrays;
  作用：将数组的元素变成字符串
    "["+元素1+","+元素2+","+…………+元素n+"]"

数组的赋值--元素的替换
  reg:int[] a = new int[5];{0,0,0,0,0}
       a[0] = 1;//1会把原来下标上的元素覆盖掉{1,0,0,0,0}
   a[1] = 3;//{1,3,0,0,0}
   a[2] = 5;//{1,3,5,0,0}
   a[3] = 7;//{1,3,5,7,0}
   a[4] = 9;//{1,3,5,7,9}
冒泡排序：
规则：挨着的两个元素进行比较，如果前一个元素大于后一个，就交换，
int[] a = {6,3,4,2,5,1};
第一轮：找到最大的
第一次：   {3,6,4,2,5,1};
第二次：   {3,4,6,2,5,1};
第三次：   {3,4,2,6,5,1};
第四次：   {3,4,2,5,6,1};
第五次：   {3,4,2,5,1,6};
第二轮：找到第二大的
  第一次：   {3,4,2,5,1,6};
  第二次：   {3,2,4,5,1,6}
  第三次：   {3,2,4,5,1,6}
  第四次：   {3,2,4,1,5,6}
第三轮：找到第三大的
  第一次:    {2,3,4,1,5,6}
    第二次：  {2,3,4,1,5,6}
  第三次:    {2,3,1,4,5,6}
第四轮：找到第四大的
第一次： {2,3,1,4,5,6}
第二次:    {2,1,3,4,5,6}
第五轮：找到第五大的
第一次： {1,2,3,4,5,6}

规律：每一轮都可以找到一个最大的，

每一轮都是从头开始比较的
每一轮最后都不用和上一轮找的那个数进行比较
           每一轮都会较上一轮少一次 

数组中含有的元素：length ==7

轮数： length-1；
第一轮：比较次数  6
第二轮：比较次数  5
第三轮：比较次数  4
第四轮：比较次数  3
第五轮：比较次数  2
第六轮：比较次数  1

System.arraycopy(p1,p2,p3,p4,p5);
p1:要复制谁，--源数组
p2:从源数组的哪个下标开始复制
p3:复制到哪个数组---目标数组
p4:目标数组从哪个下标开始
p5:复制源数组元素的长度
 Arrays.copyOf(p1,p2);
p1:源数组,
p2:扩容后的长度
会得到一个新的数组
  int[] a = new int[]{1,2,3,4};
   //想让a里存1,2,3,4,5,6
   int[] b = new int[6];
  System.arraycopy(a,0,b,0,a.length);
   b[4]=5;
   b[5]=6;
   a = b;
   System.out.println(Arrays.toString(a));