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

小梁同学 の

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
//	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
//	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
//	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
//	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
//	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
//	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
//顺序---二分查找(基础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----下一章节: 跳转

你可能感兴趣的:(Java源码,java,开发语言,经验分享,其他)