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----下一章节: 跳转