黑马程序员_Java基础(2)

最新推荐文章于 2023-07-18 17:20:24 发布

你好hmm

最新推荐文章于 2023-07-18 17:20:24 发布

阅读量588

点赞数

分类专栏： Java 文章标签： java 黑马程序员

本文链接：https://blog.csdn.net/u013921901/article/details/20621023

版权

Java 专栏收录该内容

24 篇文章 0 订阅

订阅专栏

------- android培训、java培训、期待与您交流！ ----------

Java中的语句：
|--Java中的语句均由分号（;）结束，或由一个大开括号包裹形成一条语句，只有分号的语句叫做空语句。Java中语句结构分三种：分别是顺序语句、分支语句、循环语句。
|--顺序语句：顺序语句即按照一定的执行顺序编写的语句序列，顺序语句的执行顺序由上至下。
例如:

int a = 1;  
System.out.println(a);  
System.out.println(b);//这个在编译时期就不能通过了，程序执行到此b这个变量还未定义。  
int b = 2;

|--分支语句：分支语句是满足某种特定条件后执行特定的语句序列的语句结构，根据条件的设定与实际执行的结果决定程序的执行流程。分支语句共三种if语句、if……else……语句、switch语句。
if语句：格式

if(布尔表达式){  
  
    语句（组）；  
  
}

布尔表达式的结果为真时才会执行大括号中的内容。
|--条件报答式只需满足结果职位boolean型的数据即可，例如关系表达式，逻辑表达式或是布尔类型的变量或常量，如果语句序列只有一句执行语句，括号可省略。
if……else……语句：格式

if(条件表达式){  
  
     条件表达式为真时执行的语句序列  
  
}else{  
  
    条件表达式为假时执行的语句序列  
  
}

条件表达式为真，执行if后面的大括号内的内容，如果为假执行else后面大括号内的内容。

分支语句嵌套：格式  
格式  
    if(条件表达式){  
        …  
        if(条件表达式){  
            …  
        }  
        …  
    }

|--分支语句switch格式：

switch(变量){  
  
    case 值1：语句序列; [break;]  
  
    case 值2：语句序列; [break;]  
  
    case 值3：语句序列; [break;]  
  
    default:语句序列;  
  
}

        switch语句判定的变量必须是byte,short,int,char类型中的任意一种
        jdk6.0加入对枚举类型的兼容
        jdk7.0加入对字符串类型的兼容。

        当switch表达式的值与case语句的值相匹配时，执行从该case开始的语句，直到遇到一个break语句或到达该switch语句的末端。
        default语句定义了所有case都不满足的情况下执行的语句，无论default处于何处，并且default语句沿用switch语句的break退出语句结构的特点
   |--循环语句：循环语句是反复执行同一动作的机制。他有三种结构：for、while、do...while。
     for循环格式：

for(语句序列1；条件表达式；语句序列2){  
  
    语句序列3；  
  
}

    for语句的执行顺序是：语句序列1→条件表达式→语句序列3 →语句序列2 →条件表达式→语句序列3 →语句序列2 →条件表达式…
                for语句结束于条件表达式为假的情况
   for循环还有一种特殊的格式，用于循环数组与集合对象，称为增强for循环。使用增强for循环可以简化for循环的书写格式
    语法格式：

for(迭代数据类型  变量名: 迭代对象){  
    …  
 }

while循环格式：

while(条件表达式){  
    循环体条件表达式为真时执行的语句序列  
}

     条件表达式控制循环体的执行，在循环体执行前总是先计算循环条件以决定是否执行它。若条件为true，则执行循环体，若条件为false，则终止整个循环。


     do…while格式：

do{  
    循环体，循环执行的语句序列  
} while(条件表达式)；

     do…while循环与while循环不同，先执行大括号内的内容，然后检测条件表达式是否继续执行循环体的内容。


           循环嵌套：循环中出现循环，不限定使用何种循环。

   |--break：break作用是跳出循环体
          在循环中如果执行到break语句，立即停止循环，执行循环体结束大括号后面的内容
          带标号的break
          为循环起名，使用带标号的break，可以控制对应名称的循环

    |--continue：作用是提前结束本轮循环
           在循环中如果执行到continue语句，立即停止执行continue到结束大括号前的循环体，循环并不停止。
           带标号的continue：为循环起名，使用带标号的continue ，可以控制对应名称的循环。

数组：
Java程序运算过程中，需要使用大量的数据，常见的数据形态有常量与变量。当需要一次性使用多个变量时，需要进行多次定义。为避免该现象的发生，Java语言提供了一种一次性声明创建多个变量的用于存储数据机制，该机制即为数组。

数组的基本概念：

数组是一种存放数据的容器
数组的数据数据类型都相同
数组具有一个固定的长度
数组中的数据都有一个唯一的编号叫做数组元素索引或数组元素下标
数组的索引从0开始
访问数组中的元素使用索引来访问
创建数组的内存空间使用new关键字实现

数组的内存结构：

Java内存区域的划分：1）寄存器。2）本地方法区。3）方法区。 4）栈内存。5）堆内存。

为什么划分这么区域？因为每一个内存区域对数据的处理方式不同。目前要讲的就是栈和堆。

1）栈内存的特点：存储都是局部变量

(函数参数,函数内定义的变量,语句中定义的变量)变量一旦使用完(作用域结束)，就会在栈内存中自动释放。

2）堆内存特点：存储的是实体

1.堆内存中的实体都有首内存地址值.

2.堆内存中的变量都有默认初始化值.

3.对于没有任何引用变量指向的实体，会视为垃圾，会被垃圾回收机制所回收。

(数组和对象，只要是new的，都在堆内存中)

数组的定义格式：

格式1：  
数据类型[]  数组名 ;  
int[]   arr ;         
pan style="font-family:宋体;">    </span>double[]  arr1;  
boolean  arr2  []；    
pan style="font-family:宋体;">    </span>long  []  arr3；  
  
格式2：  
数据类型[]  数组名 =  new  数据类型[数组长度];  
int[]  arr = new int[4];  
double  []  arr1 = new double[5];  
long[]  errorArray = new int[10];  
  
格式3：  
数据类型[]  数组名 = new  数据类型[]{数组元素列表};  
数组元素列表包含数组中所有元素，中间用,分割  
int[]  arr = new int[]{1,3,5,7,9};  
long[]  arr1 = new long[] {2,4,6L,8,10L};  
long[]  errorArray = new long[] {3.14 , 80L,6e6};  
  
格式4：  
数据类型[]  数组名 = {数组元素列表};  
int[]  arr = {1,3,5,7,9};       不能分开赋值

数组元素读取与修改：
数组是包含了一系列相同类型数据的容器，获取数组中的数据需要通过索引来访问，数组中的数据称为数组元素。
数组元素的修改

格式：数组名[索引] = 值;  
 int []  arr = new int[4];         
 arr[1] = 100;

数组元素的读取

格式：数组名[索引]; int [] arr = new int[4];  
  
System.out.println(arr[0]);

数组元素的默认值：
整型初始值全部为0
实型初始值全部为0.0
布尔型初始值全部为false
字符型初始值全部为/u0000对应的空字符
其他类型初始值全部为null
数组元素的遍历:
数组元素的遍历即对数组中所有的元素逐一访问。基于数组的索引特性，可以使用循环的形式对数组中的元素进行逐一访问。
遍历数组时，获取数组的元素总数可以使用length来获取，具体格式如下：
数组名.length
arr.length
数组长度值不可修改，在数组初始化阶段已经设置完成
二维数组：
二维数组的基本概念：
二维数组可以看做是一种特殊的一维数组，即数组中的元素全部是一维数组
二维数组中保存的一维数组必须结构相同，即保存的数组存储的数据类型必须完全相同
二维数组的长度仅仅表明其中保存的一维数组的数量，并不能约束其中保存的一维数组的长度
二维数组内存结构：
二维数组可以看成是特殊的一维数组，二维数组内存结构与一维数组内存结构极其相似，只是在一维数组保存的数据方面略有不同。
二维数组定义格式：

格式1：  
  
数据类型[][]  数组名 ;  
  
int[][]   arr ; double[][]  arr1;  
  
boolean[]  arr2  []; long  arr3 [] [];  
  
格式2：  
  
数据类型[] [] 数组名 =  new  数据类型[长度] [长度];  
  
int[][] arr = new int[4][5];  
  
double  [][]  arr1 = new double[5][10];  
  
long[][]  errorArray = new int[10][20];  
  
格式3：  
  
数据类型[][]  数组名 = new  数据类型[][]{{数组元素列表1},{数组元素列表2},……};  
  
int[][] arr = new int[][]{{1,3},{7,9}};  
  
long[][] arr1 = new long[][] {{2,4},{6L,8},{10L,12L}};  
  
long[][]  errorArray = new long[] {{3.14 , 80L}};  
  
int[][] arr2 = new int[][]{};  
  
int[][] arr2 = new int[][]{{},{}};  
  
格式4：  
  
数据类型[][]  数组名 = {{数组元素列表1}, {数组元素列表2},……};  不 能分开赋值  
  
int[][]  arr = {{1,3},{5,7}};  
  
int[][]  errorArray1 = {{1,3},5,7,{9,11}};  
  
int[][]  errorArray2 ={1,3,5,7,9};  
  
int[][]  array3 ;  
  
array3 = {{1,3},{5,7}};  
  
格式5：  
  
数据类型[][]  数组名 = new 数据类型[长度][];  
  
数组名[索引] = new 数据类型[长度];

先对二维数组外层数组的长度进行初始化，然后再对其中保存的数据即内层一维数组进行单独初始化
使用此格式可以创建出特殊的二维数组，即其中保存数据的一维数组长度均不相同
此格式更有利于对现实生活中的数据进行描述
二维数组的数据存储位置：
二维数组数组中的数据均保存在第二维的数组中，因此在访问时，二维数组中每个元素均拥有两个索引值，任意两个数组元素的两个索引值不完全相同
二维数组数据读写：
数组元素的修改

//格式：数组名[第一层索引] [第二层索引] = 值;  
  
int [][]  arr = new int[4][4];        
  
arr[1][1] = 100;

数组元素的读取

//格式：数组名[第一层索引] [第二层索引];  
  
int [][]  arr = new int[4][9];        
  
System.out.println(arr[0][0]);  
  
System.out.println(arr[10][10]);

二维数组的遍历：
二维数组的遍历看做是特殊的一维数组，从第一层中取出的数据不是真实数据，而是一个一维数组，然后对取出的数组再进行遍历
数组与数据类型：
数组是一种特殊的数据类型
数组在内存中的以“引用”的形式描述
引用即参照，即对应存储的数据指向另一个实际存储数据的区域，中间的联系使用内存地址进行
数组最值：
数组的最值可通过对数组中元素遍历，逐一比对，最终找到数组元素的最值。
在进行数组最值的求解过程中，尽量避免使用固定值对数组元素进行比对，避免出现特殊值影响最终结果，可以改变数据保存的方式，使用索引作为保存的数据，完成求最值元素对应的下标的形式来避免上述问题
数组排序：
数组排序是数组的常用操作，数组排序方式有多种
冒泡排序法交换排序法选择排序法
插入排序法基数排序法希尔排序法
快速排序法归并排序法堆排序法
选择排序法：
选择排序法是将原始数组空间分为两个部分，第一部分用于存放已经排序完成的数据，第二部分用于存在未完成排序的数据。

排序过程中，每次从未完成排序的区域中找出最大/小值并将其放置到未完成排序区域的首位，然后改变两个区域的空间大小，并反复上述过程，直到未排序区只有一个数据。
代码体现：

public static void selectSort(int[] arr) {  
    //  -1是因为j+1小标就能保证所有元素都能够取到，并且不会下标越界。  
    for (int i = 0; i < arr.length - 1; i++) {   
        for (int j = i + 1; j < arr.length; j++) {  
            // 如果arr[i]比arr[j]的值大，就把它们的值互换。  
            if (arr[i] > arr[j]) {  
                swap(arr, i, j);   //满足条件，位置置换  
            }  
        }  
    }  
}

冒泡排序法:
冒泡排序法是较为常用的排序方法，日常生活中大多数的排序方案均为冒泡排序法.

排序过程中，使用第一个元素与第二个元素进行比较，并将其较大/小的放在后面，然后使用第二个与第三个元素进行比较，重复上述操作，当数组遍历一轮时，最大/小的元素将置于数组末端；第二轮，改变遍历数组范围，从第一个元素到倒数第二个元素，对其进行上述操作；第三轮对第一个元素到倒数第三个元素进行上述操作，如此反复，最终对数组实现排序.
代码体现：

public static void bubbleSort(int[] arr) {  
    for (int i = 0; i < arr.length - 1; i++) {  
        /* -i是因为i增加一次，意味着一个元素数组的最小（大）元素位置已经 
         * 确定。已不需要在比较它。-1是保证下标为j+1的元素不会越界 
         */  
        for (int j = 0; j < arr.length - i - 1; j++) {    
            if (arr[j] < arr[j + 1]) {  //  如果前面的元素的值比后面那个小，则换位置。  
                swap(arr, j, j + 1);   //满足条件，位置置换  
            }  
        }  
    }  
}

数组元素查找：
数组中元素众多，最快速度的查找出需要的数据成为数组操作中的一个重要操作，常用查找方式如下
二分法查找索引查找法哈希查找法
二分法查找：
二分法查找又名折半查找法，首先要保障要查询的数据是有序的，然后与数据总量一半位置处的数据进行比对，以升序排列为例，如果比对的结果发现查找数据比比对数据大，则在后半段再次重复上述操作，直到找到最终的数据。如果原始数据中不包含要查找的数据，数据查找将失败，通常返回一个固定的值-1作为查找失败的结果。

public static int halfSearch(int[] arr, int key) {  
    int min = 0, max = arr.length - 1, mid;  
    mid = (min + max)/2;  
    while(arr[mid] != key) {  
        if (key > arr[mid])   
            min = mid + 1;  
        else  
            max = mid - 1;  
        // 如果没有找到则退出当前循环（最小角标都大于了最大角标）  
        if(min <= max)  
            mid = (min + max)/2;  
        else  
            return -1;  
    }  
    return mid;  
}

// 折半查找法2（判断角标大小来作为循环的条件）  
public static int halfSearch_2(int[] arr, int key) {  
    int min = 0, max = arr.length - 1, mid;  
    while(min <= max) {  
        mid = (min + max)/2;  
        if(key > arr[mid])  
            min = mid + 1;  
        else if(key < arr[mid])  
            max = mid - 1;  
        else   
            return mid;  
    }  
    return -1;  
}