java基础语法学习day06---初学者必看详解

淡淡的烟草味﹌ 2022-10-17 13:49 239阅读 0赞

### java基础语法学习day06---初学者必看详解 ###

*  1、数组
 *   *  1.1 什么是数组
     *  1.2 数组的定义
     *  1.3 数组的初始化
     *  1.4数组的访问
     *   *  获取数组的长度
         *  通过下标访问数组元素
         *  遍历数组元素
         *  练习：求数组元素最大值
     *  1.5 数组的复制
     *   *  System.arraycopy方法用于数组复制
         *  Arrays.copyOf方法用于数组复制
         *  数组的扩容
         *  练习：求数组元素的最大值放在最后一位
     *  1.6 数组排序
     *   *  数组的排序说明
         *  数组冒泡排序算法
         *  冒泡排序算法实现
         *  Arrays.sort方法用于数组排序

# 1、数组 #

## 1.1 什么是数组 ##

*  程序 = 算法 + 数据结构；
 *  前面学习的if、if-else、switch、循环解决的都是流程问题，即算法问题。
 *  所谓数据结构，简单说就是把数据按照特定的某种结构来保存，设计合理的数据结构是解决问题的前提。
 *  数组就是最基本的一种数据结构。

- 相同数据类型的元素组成的集合
    - 元素按线性顺序排列。所谓线性顺序是指除第一个元素外，每一个元素都有唯一的前驱元素；除最后一个元素外，每一个元素都有唯一的后继元素（“一个跟一个”）
    - 可以通过元素所在位置的顺序号（下标）做标识来访问每一个元素（下标从0开始，最大到元素个数-1）

## 1.2 数组的定义 ##

声明数组的语法：

数据类型[  ]   数组名 = new  数据类型 [ 大小 ] ;
    例：  int [  ]     arr    = new       int      [   10  ] ;

说明：

*  数组类型，int\[\]表示数组中的每一个元素都是int类型。
 *  数组类型变量（引用）。
 *  数组的长度，即数组中元素的个数。

## 1.3 数组的初始化 ##

基本类型的数组创建后，其元素的初始值：byte、short、char、int、long为0；float和double为0.0；boolean为false  
可以在数组声明的同时对数组的元素进行初始化，例如：

int [ ] arr = {
         10,23,30,-10,21 } ;

此种写法只能用于声明时的初始化，不能用于赋值。如下面代码会有编译错误。

int [ ] arr;
        arr = {
         10,23,30,-10,21 } ;

可以通过下面的方式给已经声明的数组类型变量进行初始化：

int [ ] arr ;  
       arr = new int[ ]{
        10,23,30,-10,96 } ;

**注意：\[\]中不可以写长度，元素的个数就是数组的长度。**

## 1.4数组的访问 ##

### 获取数组的长度 ###

调用数组的length属性可以获取数组的长度：

int[] arr = new int[]{
         3,6,8,9 };
       int len = arr . length ;
       System.out.println(“数组长度为:” + len);
      上述代码输出结果为：数组长度为:4

### 通过下标访问数组元素 ###

数组中的元素通过下标的方式进行访问：

例如：
                int[ ] arr = new int[]{
         4,5,6,8};
                int  temp = arr [ 2 ];   // 获取第3个元素—6
                // 交换数组下标为2和3的两个相邻元素的值
                int  temp = arr [ 2 ] ;
                arr [ 2 ] = arr [ 3 ] ;
                arr [ 3 ] = temp ; 
                // 交换后结果：4,5,8,6

### 遍历数组元素 ###

遍历数组元素，通常选择for循环语句，循环变量作为访问数组元素的下标，即可访问数组中的每一个元素

int[] arr = new int[10];  
         for ( int i = 0 ; i < arr.length ; i ++ ){
        
                arr [ i ] = 100;
          }

**注意：循环的计数器的变化范围从0~length- 1**

遍历数组元素，正序输出

int [ ] arr = new int [ ] {
        10,20,30,40,50 } ;
       for ( int i=0; i< arr.length; i++) {
        
        System.out.println ( arr[ i ] ) ;
       }

遍历数组元素，逆序输出

int [ ] arr = new int [ ] {
        10,20,30,40,50 } ;
       for ( int i = (arr.length -1) ; i >= 0 ; i -- ) {
        
      System.out.println ( arr[ i ] ) ;
       }

### 练习：求数组元素最大值 ###

## 1.5 数组的复制 ##

### System.arraycopy方法用于数组复制 ###

使用System.arraycopy( )方法可以实现数组的复制

public static void arraycopy(Object src, int srcPos,
                                Object dest, int destPos, int length)
    src		– 源数组
    srcPos		– 源数组中的起始位置
    dest		– 目标数组
    destPos	– 目标数组中的起始位置
    length 	– 要复制的数组元素的数量

System.arraycopy方法用于数组复制

int[ ] a   = {
         10 ,20 ,30 ,40 ,50 };
    int[ ] a1 = new int[ 6 ] ;
    System.arraycopy( a , 1 , a1 , 0 , 4 );

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYzOTE4MA_size_16_color_FFFFFF_t_70]

### Arrays.copyOf方法用于数组复制 ###

使用java.util.Arrays类的copyOf方法可实现数组的复制

类型[ ]  newArray  = Arrays.copyOf ( 
                        类型[ ]  original , int  newLength );

特点：生成的新数组是原始数组的副本  
newLength小于源数组，则进行截取  
newLength大于源数组，则用0或 null进行填充  
所以产生的新数组可以大于源数组的长度

int [ ]  a = {
         10,20,30,40,50 } ;
     int [ ]   a1 = Arrays . copyOf (  a, 6 ); 
      a1数组元素为： 10 20 30 40 50 0

### 数组的扩容 ###

数组的长度在创建后是不可改变的，所谓扩容是指创建一个更大的新数组并将原有数组的内容复制到其中。  
可以通过Arrays.copyOf()方法，简便实现数组的扩展。

int [ ]  a = {
         10,20,30,40,50 } ;
         a = Arrays . copyOf (  a, a.length+1 );
         
         输出a数组元素：10,20,30,40,50,0

### 练习：求数组元素的最大值放在最后一位 ###

*  找出数组元素中的最大值并将找出的最大值放在数组最后一个元素的下一个位置。

## 1.6 数组排序 ##

### 数组的排序说明 ###

排序是对数组施加的最常用的算法；
    所谓排序，是指将数组元素按照从小到大或从大到小的顺序重新排列；
    对于元素较多的数组，排序算法的优劣至关重要；
    一般情况下，通过排序过程中数组元素的交换次数来衡量排序算法的优劣；
    常用的排序算法有：插入排序、冒泡排序、快速排序等。

### 数组冒泡排序算法 ###

*  冒泡排序的原则：比较相邻的元素，如果违反最后的顺序准则，则交换
 *  可以简化理解为：
    
     *  第一次找到所有元素中最大的放在最后一个位置上，不再变动；
     *  第二次找到剩余所有元素中最大的放在倒数第二个位置上，不再变动；
     *  以此类推，直到排序完成。
 *  比较时既可以采用“下沉”的方式，也可以使用“上浮”的方式实现。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYzOTE4MA_size_16_color_FFFFFF_t_70 1]

### 冒泡排序算法实现 ###

*  声明数组，包含如下12个元素，对其进行冒泡排序  
    \[32, 58, 38, 48, 43, 60, 13, 34, 20, 47, 87, 20\]

import java.util.Random;
    import java.util.Arrays;
    
    public class BubbleSort {
        
    	public static void main(String[] args) {
        
    		//创建数组
    		int[] arr = new int[10];
         Random ran = new Random();
    		for (int i = 0; i < arr.length; i++) {
        
    			arr[i] = ran.nextInt(100);
    		}
    		System.out.println(Arrays.toString(arr));
    		// 冒泡排序
    		System.out.println("----------冒泡排序 开始----------");
    		for (int i = 0; i < arr.length - 1; i++) {
        
    			for (int j = 0; j < arr.length - i - 1; j++) {
        
    				if (arr[j] > arr[j + 1]) {
        
    					int t = arr[j];
    					arr[j] = arr[j + 1];
    					arr[j + 1] = t;
    				}
    			}
    			System.out.println(Arrays.toString(arr));
    		}
    		System.out.println("----------冒泡排序 结束----------");
    		System.out.println(Arrays.toString(arr));
    	}
    }

### Arrays.sort方法用于数组排序 ###

JDK提供的Arrays.sort（）方法封装了数组的排序算法：

int[ ] arr = {
         49, 81, 1, 64, 77, 50, 0, 54, 77, 18 };
    Arrays.sort ( arr ) ;
    for( int i=0; i<arr.length; i++) {
        
    	System.out.println( arr[i] );
    }
    输出结果：0  1  18  49  50  54  64  77  77  81

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYzOTE4MA_size_16_color_FFFFFF_t_70]: /images/20221014/7ff01cebc5c2430299a1685f98588698.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYzOTE4MA_size_16_color_FFFFFF_t_70 1]: /images/20221014/46ad153f421440a6bda4faf0e0fcec40.png