java入门基础---1.3---数组，排序，方法引出及二分查找

小梁の同学

已于 2022-07-19 23:29:40 修改

阅读量464

点赞数

分类专栏： Java源码文章标签： java 开发语言经验分享其他

于 2022-07-07 00:41:22 首次发布

本文链接：https://blog.csdn.net/weixin_50123823/article/details/125650478

版权

Java源码专栏收录该内容

15 篇文章 0 订阅

订阅专栏

小梁同学の

Java学习旅途

你好！这是小梁同学使用博客所记录的文章笔记，作为一个初学者的从基础到未来的记录，如果你想和我一起在Java学习路程上坚持下去，欢迎你的关注与指正。

新的将来

万丈高楼平地起，未来只能靠自己
从无到有，从零到一，学习路上没有尽头
每日一文，每日一记，跟着软件向前努力
加油！！！！！

详解代码均在以下标题后的链接中

以下所有有关代码，都是个人在上完课后自己重新敲代码之后所做笔记后上传，并非原搬直接上传，谢谢理解

七.数组类型

一.数组

1.定义

数据存储，一个变量存储多个数据，多个数据组合在一起，进行存储

2.存储数据

1.定义数组：数组类型进行数据存放

定义方式：[] 例:int[]

2.定义变量：数据类型

定义方式：变量名= 值 例;int a =1;

3.数组存储

1.知道具体每个位置数据，一一列举（数据量较小）

int[] array={1,2,3,4,5,6,7,8,9};

2.不知道各位置具体数据(数据量较大)

int[] arr=new int[100]; ==>没有给每个位置上赋值，数组的每个位置上有自己的默认值

int 数组每个位置上的默认值 0
short 数组每个位置上的默认值 0
byte 数组每个位置上的默认值 0
long数组每个位置上的默认值 0
==================整数类型的数组默认值都是0
float 数组每个位置上的默认值 0.0
double数组每个位置上的默认值 0.0
==================小数类型的数组默认值都是0.0
char 数组每个位置上的默认值 ascii表的第一个字符 数字值 0  ‘\u0000’
boolean数组每个位置上的默认值 false 
String 数组，数组每个位置上的默认值 null

3.前两种结合：Int[] arr = new int[] {};

4.注意

1. 开始的范围

0是索引开始的位置

2. 数组：获取数组中数据的个数：

变量 . length 数组变量的长度（数据的个数）

3. 结束的范围

索引结束的下标：length-1（Java中下标没有-1，和其他语言不同）

4. 取出

数据类型变量 = 数组变量[下标]========》获取到指定位置上的数据

5. 修改

数组变量[下标]=值================》新的值进行覆盖，修改

6.数组优点

一个变量存储多个值

7.数组缺点

数组一旦定义，长度就固定了，长度不可以修改

8.异常

修改数组中数据的个数，出现异常

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 7
	at com.bjpowernode.day8.Test.main(Test.java:9)

二.冒泡排序(思维顺序)

//自小向大---->
int[] arr={1,5,645,34,32,0};

//第一次冒泡，拿到一个最大值（思维基础一----相邻比较）
//第一个数和第二个数进行比较
if(arr[0]>arr[1]){
    int tmp=arr[0];
    arr[0]=arr[1];
    arr[1]=tmp;
}
//for(int i=0;i<arr.length;i++){
//	System.out.println(arr[i]);
//}
=======1,5,645,34,32,0
//第二个数和第三个数进行比较
if(arr[1]>arr[2]){
 	int tmp=arr[1];
    arr[1]=arr[2];
    arr[2]=tmp;
}
//for(int i=0;i<arr.length;i++){
//	System.out.println(arr[i]);
//}
=======1,5,645,34,32,0
//第三个数和第四个数进行比较
if(arr[2]>arr[3]){
 	int tmp=arr[2];
    arr[2]=arr[3];
    arr[3]=tmp;
}
//for(int i=0;i<arr.length;i++){
//	System.out.println(arr[i]);
//}
=======1,5,34,645,32,0
//第四个数和第五个数进行比较
if(arr[3]>arr[4]){
 	int tmp=arr[3];
    arr[3]=arr[4];
    arr[4]=tmp;
}
//for(int i=0;i<arr.length;i++){
//	System.out.println(arr[i]);
//}
=======1,5,34,32,645,0
//第五个数和第六个数进行比较
if(arr[4]>arr[5]){
 	int tmp=arr[4];
    arr[4]=arr[5];
    arr[5]=tmp;
}
//for(int i=0;i<arr.length;i++){
//	System.out.println(arr[i]);
//}
=======1,5,34,32,0,645

冒泡的逻辑的代码重复多次出现===》代码冗余===》解决冗余===》一次书写不冗余

//第一次冒泡，拿到一个最大值（思维基础二----合并相邻比较）
int[] arr={1,5,645,34,32,0};
for(int i=0;i<arr.length-1;i++){
    if(arr[i]>arr[i+1]){
 	int tmp=arr[i];
    arr[i]=arr[i+1];
    arr[i+1]=tmp;
	}
}
//for(int i=0;i<arr.length;i++){
//	System.out.println(arr[i]);
//}
=======1,5,34,32,0,645
  
    
 //通过重复以上冒泡语句进行后，可得到最终结果
=======0,1,5,32,34,645
 //但此结果得到时，以上程序在代码中依旧显示为冗余多遍，故要解决冗余

//冒泡排序，拿到从小到大的顺序值（思维基础三----合并多次冒泡代码）
int[] arr={1,5,645,34,32,0};
for(int j=0;j<arr.length-1;j++){
    for(int i=0;i<arr.length-1-j;i++){
    	if(arr[i]>arr[i+1]){
 			int tmp=arr[i];
    		arr[i]=arr[i+1];
    		arr[i+1]=tmp;
		}
	}
}
for(int i=0;i<arr.length;i++){
	System.out.println(arr[i]);
}
=======0,1,5,32,34,645

三.方法

一.引出

1.循环：对于同一个变量进行的数据更新

多组数据进行冒泡，当前的冒泡逻辑重复的情况，不能用循环完成逻辑，因为现在操作的变量不是一个，循环不能解决当前冒泡排序冗余的情况。

2 方法：所有的方法，具有功能，一定具有某种功能

方法：方法具有功能，具有冒泡排序的功能

Main方法，程序的入口，main方法具有程序入口的功能

3.方法组成：

public static void main(String[] args)===》方法的声明（签名）

{}=方法的逻辑=》方法体

4.方法书写位置：

只能放在class（类）文件，

不能出现方法套方法的情况（方法中写方法）

方法解决代码冗余===>书写一次，解决冗余，方法定义

5.方法的执行

1 定义方法，逻辑写到方法中

2 调用方法，调用方法才能执行

6.方法定义

操作的数据，不能定义在方法内部

定义在内部，数据固定了，只能对当前的这个数据进行操作，不能操作其他数据，如果我们每次操作的数据不同，数据需要动态的发生改变。

7.数据定义

数据定义在方法的小括号中（变量的声明数据类型变量名==》方法的形式参数==》方法的形参）

定义方法，方法需要接收数据，数据定义成形参

8.有参和无参

判断：方法是否每次操作的数据不同

如果不同，方法的小括号中写形参（数据类型，数据的个数，数据的顺序）–>有参方法

如果相同，小括号中没有----------------->无参方法

9.方法调用

执行方法体，执行方法，需要知道要操作的是哪个数组，知道了具体要操作的的哪个数据值，把操作的数据告诉方法，通过（）进行形参的赋值，形参的数据类型，个数，顺序

给形参赋予的实际的值=====》实际参数值=====》实参

10.通用性

方法不在具有局限性，不局限于某一个数据

public class test{
	public static void sort(int[] arr){
    	for(int j=0;j<arr.length-1;j++){
    		for(int i=0;i<arr.length-1-j;i++){
    			if(arr[i]>arr[i+1]){
 					int tmp=arr[i];
    				arr[i]=arr[i+1];
    				arr[i+1]=tmp;
				}
			}
		}
        for(int i=0;i<arr.length;i++){
            System.out.println(arr);
        }
	}
    public static void main(String[] args){
        int[] arr1={5,4,9,7,8,2,6,10,50,21};
        int[] arr2={52,24,95,45,12,56,8,79};
        sort(arr1);  
        sort(arr2); 
    }
}
===========================================
    2,4,5,6,7,8,9,10,21,50
    8,12,24,45,52,56,79,95

二.返回值

1.返回return

需要在一个方法中，用到另一个方法的计算结果的数字，在一个方法中，拿到另一个方法中的数字

借助于方法：方法计算的结果进行返回

如果需要使用方法中的数据，在进行其他操作，方法定义成有返回值的方法

2.方法定义时

方法可以根据是否要拿到方法中的数据继续做其他操作

如果要进行其他操作，方法定义成有返回值的方法，返回的数据值是什么类型，是什么类型

方法名前返回数据的数据类型，只要有返回值，一定要return后加上要返回的数据

如果不需要，方法定义成无返回值的方法 ============ 方法名前 void

3.方法调用时

方法是否有返回值

如果有，调用方法是，用对应类型的变量进行接收

如果没有，调用方法，不要接收

4.定义方法时

方法是否每次操作的数据不同，进行方法的分类========》有参和无参方法

方法是否要方法中数据进行其他操作，进行分类=========》有返回值和无返回值

5.方法调用

方法是否有参数=================》调用时，出入实参

方法是否有返回值===============》调用，对应类型变量接收

public class test{
	public static int max(int[] arr){
    	for(int j=0;j<arr.length-1;j++){
    		for(int i=0;i<arr.length-1-j;i++){
    			if(arr[i]>arr[i+1]){
 					int tmp=arr[i];
    				arr[i]=arr[i+1];
    				arr[i+1]=tmp;
				}
			}
		}
        return arr[arr.length-1];
	}
    public static void main(String[] args){
        int[] arr1={5,4,9,7,8,2,6,10,50,21};
        int[] arr2={52,24,95,45,12,56,8,79};
        int a = max(arr1);  
        int b = max(arr2); 
        System.out.println(a+b);
    }
}
===========================================
    145

四.二分查找

一半一半的进行查找，一定要在有序的数组

//引出----查找一个数值方式
public static void main(String[] args){
    int[] arr={5,8,45,95,21,45,65,22,8,996,246,15};
    int num = 996;
    for(int i=0;i<arr.length;i++){
        if(arr[i]==num){
            System.out.println(num);
            return;
        }
    }
    System.out.println("没有");
}
============================================
    996

//顺序---二分查找（基础1000个数中找到999）
public static void main(String[] args){
    int[] arr = new int[1000];
    for(int i=0;i<arr.length;i++){
        arr[i]=i+1;
    }
    int num=999;
    int start=0;
    int end=arr.length-1;
    int count=0;
    while(start<=end){
        count++;
        int middle=(start+end)/2;
        if(arr[middle]==num){
            System.out.println(num);
            System.out.println(count);
            return;
        }else if(arr[middle]>num){
            end=middle-1;
        }else{
            start=middle+1;
        }
    }
    System.out.println("没有")；  
}
==============================
    999
    9

//将二分查找定义方法
public class test{
    public static int search(int[] arr,int num){
    	int start=0;
    	int end=arr.length-1;
    	int count=0;
    	while(start<=end){
            count++;
            int middle=(start+end)/2;
        	if(arr[middle]==num){
            	return middle;
        	}else if(arr[middle]>num){
            	end=middle-1;
        	}else{
            	start=middle+1;
        	}
    	}
    	return -1;
	}
	public static void main(String[] args){
    	int[] arr = new int[1000];
    	for(int i=0;i<arr.length;i++){
        	arr[i]=i+1;
    	}
    	int num=999;
    	System.out.println(search(arr,num));
	}
}
=================================
    998

java入门基础—1.2----上一章节: 跳转

java入门基础—1.4----下一章节: 跳转

小梁の同学

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java入门基础---1.3---数组，排序，方法引出及二分查找

小梁同学の以下所有有关代码，都是个人在上完课后自己重新敲代码之后所做笔记后上传，并非原搬直接上传，谢谢理解数据存储，一个变量存储多个数据，多个数据组合在一起，进行存储定义方式：[] 例:int[] 定义方式：变量名= 值例;int a =1;int[] array={1,2,3,4,5,6,7,8,9};int[] arr=new int[100]; ==>没有给每个位置上赋值，数组的每个位置上有自己的默认值3.前两种结合：Int[] arr = new int[
复制链接

扫一扫