关于java基础_数组的学习

数组的学习
1.数组的概念?作用是什么?
系统中存储多个值,
2.数组的定义?
数据类型[] 数组名;

3.定义好数组以后需要对其进行初始化
数组初始化有两种:
第一种动态初始化,指定数组的长度,长度指数组中可以存放多少条数据,一旦定义不能改变
动态初始化有两种
1,数组类型[ ] 数组名=new 数组类型[数组的长度]
2,数据类型[] 数组名;
数组名=new 数组类型[数组的长度]
如果数组动态初始化完成后,数组元素都会有一个默认值(原因:)
整数---0 小数--0.0 char--空格 boolean--false 引用数据类型----null
第二种静态初始化,
不是指定数组的长度,而是在初始化的同事给数组元素赋值
数组类型[] 数组名=new 数组类型[]{元素值1,元素值2,...}
获取,如何访问数组:
常见的数组异常:
ArrayIndexOutOfBoundsException 数组下标越界异常
NullPointerException 空指针异常

获取数组长度:数组名.length;
数组的遍历:
1.for循环

for(int i=0;i<arr7.length;i++){
             sum=sum+arr7[i];
             
         }

2.foreach
for(int a:arr) 数组第一个元素开始遍历,遍历后赋值给a,继续

for(int str:arr7){
             System.out.println(str);
         }

1.栈(Stack):主要存放局部变量
2.堆(Heap):new出来的东西都在堆里面.只要在堆里面的变量都有默认值
3,方法区(Method Area):存放.class文件
4.本地方法区:和操作系统有关
5.寄存器:和cpu有关

冒泡排序
两两比较

从大到小
10,20,30,40,50,60,70
----
20,30,40,50,60,70,10 第一趟 6次
30,40,50,60,70,20,10 第二趟 5次
40,50,60,70,30,20,10
50,60,70,40,30,20,10
60,70,50,40,30,20,10
70,60,50,40,30,20,10 第六趟 1次

7个数比较6趟
N个数比较n-1趟

次数=7-趟数

 1 package day04;
 2 /**
 3  * n个数字来排队,两两比较小靠前
 4  * 外层循环n-1
 5  * 内层循环n-1-i
 6  * @author ASUS
 7  *
 8  */
 9 public class Demo2 {
10     public static void main(String[] args) {
11         //从大到小
12         int arr[]={10,20,30,40,50,60,70};
13         //外层循环控制趟数
14         for(int i=0;i<arr.length;i++){
15             //内存循环控制次数
16             
17             
18             for(int j=0;j<arr.length-i-1;j++){
19                 //从大到小  <
20                 if(arr[j]<arr[j+1]){
21                     int temp=arr[j];
22                     arr[j]=arr[j+1];
23                     arr[j+1]=temp;    
24                 }
25             }
26             
27         }
28         for(int num:arr){
29             System.out.println(num);
30         }
31         
32     }
33 }

二维数组;数组中的数组
定义格式:
数组类型[][] 数组名;
第一个中括号代表二维数组中有几个一维数组行
第二个中括号代表每个一维数组中有几个元素列
二维数组初始化
动态初始化
静态初始化

 1 package day04;
 2 /**
 3  * 二维数组
 4  * @author ASUS
 5  *
 6  */
 7 public class Demo3 {
 8 
 9     public static void main(String[] args) {
10            //1.动态创建数组
11         int[][] arr=new int[3][4];
12         arr[0][1]=10;
13     
14           //静态初始化
15     int [][]arr1=new int[][]{{12,89,56},{75,45,45}};
16     
17     
18     //最简单
19     int[][] arr2={{12,89},{75,45,54},{75,41,54}};
20     
21     //遍历二维数组
22     //外层控制行  
23     for(int i=0;i<arr2.length;i++){
24         for(int j=0;j<arr2[i].length;j++){
25             System.out.println(arr2[i][j]+"\t");
26         }
27     }
28 }
29 }

常用知识点:

数组的复制与反转:

 1 //复制
 2          l int arr5[]=arr4.clone();
 3          System.out.println("数组的复制"+Arrays.toString(arr5));
 4          //反转
 5          for(int i=0;i<arr4.length/2;i++){
 6               int temp=arr4[i];
 7              arr4[i]=arr4[arr4.length-1-i];
 8              arr4[arr4.length-1-i]=temp;
 9          }
10         
11          System.out.println("反转后的数组"+Arrays.toString(arr4));

数组的打印:System.out.println(Arrays.toString(arr5));

1 //4.将一个字符串数组输出为|分割的形式，比如“梅西|卡卡|C罗|罗纳尔多|贝克汉姆”。
2           String [] arr2={"梅西","卡卡","c罗","罗纳尔多","贝克汉姆"};
3          for(final String str:arr2){
4              System.out.print(str+(str.equals(arr2[arr2.length-1])?"":"|")+" ");
5          }

 System.out.print(str+(str.equals(arr2[arr2.length-1])?"":"|")+" ");

常见的算法：

排序算法：
冒泡排序算法
选择排序算法

查找算法：
二分法查找

以上算法在以后的java实际开发中我们不需要使用的。
因为java已经封装好了，直接调用就行。
只不过以后面试的时候，可能会有机会碰上。

2.2、算法实际上在java中不需要精通，因为java中已经封装好了，
要排序就调用方法就行。例如：java中提供了一个数组工具类：
java.util.Arrays
Arrays是一个工具类。
其中有一个sort()方法，可以排序。静态方法，直接使用类名调用就行。

5、二分法查找（折半查找）：

第一：二分法查找建立在排序的基础之上。
第二：二分法查找效率要高于“一个挨着一个”的这种查找方式。
第三：二分法查找原理？
10(0下标) 23 56 89 100 111 222 235 500 600(下标9) arr数组

目标：找出600的下标
(0 + 9) / 2 --> 4（中间元素的下标）

arr[4]这个元素就是中间元素：arr[4]是 100
100 < 600
说明被查找的元素在100的右边。
那么此时开始下标变成：4 + 1

(5 + 9) / 2 --> 7（中间元素的下标）
arr[7] 对应的是：235
235 < 600
说明被查找的元素在235的右边。

开始下标又进行了转变：7 + 1
(8 + 9) / 2 --> 8
arr[8] --> 500
500 < 600
开始元素的下标又发生了变化：8 + 1
(9 + 9) / 2 --> 9
arr[9]是600，正好和600相等，此时找到了。

 1 package arrays;
 2 
 3 import java.util.Arrays;
 4 
 5 public class ArraysTest {
 6 
 7     public static void main(String[] args) {
 8         int[] arr={12,34,43,54,12,24,34};
 9         //排序
10         Arrays.sort(arr);
11         //二分法
12         int index=Arrays.binarySearch(arr, 34);
13         System.out.println(index==-1?"该元素不存在":"该元素下标为"+index);
14     }
15 
16 }

6、介绍一下java.util.Arrays工具类。
所有方法都是静态的，直接用类名调用

 Arrays.sort(); 排序

Arrays.binarySearch(arr, int);  二分法查找

主要使用的是两个方法：
二分法查找，排序
以后要看文档，不要死记硬背。

关于java基础_数组的学习

推荐阅读