欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

JAVA基础学习笔记(二)用来记录这几天的学习历程

程序员文章站 2024-03-15 20:21:06
...

2月14号
1、注意: 如果一个函数的返回值类型是具体的数据类型,那么该函数就必须要保证在任意情况下都保证有返回值。(除了返回值类型是void以外)

2、Return关键字
Return的作用:1.返回数据给函数的调用者
2.函数一旦执行到了return关键字,那么该函数马上结束
(能结束一个函数)
注意:一个函数的返回值类型 是void,那么也可以出现return关键字,但 是return关键字的后面不能有数据。(这时用的是return能结束一个函数)

3、return关键字和break关键字的区别:
Return关键字是结束一个函数
break关键字是结束一个循环

4、函数的重载:
在一个类中出现两个或者两个以上的同名函数,这个称作为函数的重载。
函数重载的作用:
同一个函数名可以出现了不同的函数,以应对不同个数或者不同数据类型的参数。
函数重载的要求:
1.函数名一致
2.形参列表不一致(形式参数的个数不同或者对应的数据类型不同)
3.与函数的返回值类型是无关的

5、数组:数组是同一种数据类型的集合容器。
1.数组的定义格式:
数据类型[ ] 变量名=new 数据类型[ 长度 ];
分析数组: 左边 int[] arr 声明了一个int类型的数组容器,数组名arr
int : 表示该数组容器只能存储int类型的数据
[] : 这是一个数组类型
arr : 变量名
右边:new int[50]; 创建了一个长度为50的int类型数组对象。
new : 创建数组对象的关键字。
int: 表示该数组对象只能存储int类型数据。
[]: 表示是数组类型。
50 : 该数组最多能存储50个数据。数组的容量。
2.数组的好处: 对分配到数组对象中每一个数据都分配一个编号(索引值、角标、下标),索引值的范围是从0开始,最大是: 长度-1.
3.局部变量: 如果一个变量是在一个方法(函数)的内部声明的,那么该变量就是一个局部变量。
成员变量: 成员变量就是定义在方法之外,类之内的
4.数组中常见的问题:空指针异常,下标越界
int[] arr = new int[2];
arr = null ; //null 让该变量不要引用任何的对象。 不要记录任何 的内存地址。
arr[1] = 10;
System.out.println(arr[1]);
1.NullPointerException 空指针异常
原因: 引用类型变量没有指向任何对象,而访问了对象的属性或者是调用了对象的方法。
2. ArrayIndexOutOfBoundsException 索引值越界(下标越界)
原因:访问了不存在的索引值(下标值)
5.数组的初始化方式:
动态初始化: 数据类型[] 变量名 = new 数据类型[长度];
静态初始化: 数据类型[] 变量名 = {元素1,元素2…};
如果程序一开始你就已经确定了数据,那么这时候建议使用静态初始化。 如果数据一开始还不太明确,这时候就建议使用动态初始化。

6.排序算法:
选择排序(直接排序):使用一个元素与其他的元素挨个比较一次,符合条件交换位置。
public static void selectSort(int[] arr){
//把最大值放在首位置。
for(int j = 0; j<arr.length-1; j++){ // 控制的是轮数。
for(int i = j+1 ; i<arr.length ; i++){ // 找出最大值
if(arr[i]>arr[j]){
//交换位置
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
} } } }

冒泡排序:冒泡排序的思想就是使用相邻的两个元素挨个比较一次,符合条件交换位置。
public static void bubbleSort(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 temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
} }}}

7.二分查找法
折半查找法(二分法): 使用前提必需是有序的数组。
public static int halfSearch(int[] arr, int target){
//定义三个变量分别记录最大、最小、中间的查找范围索引值
int max = arr.length-1;
int min = 0;
int mid = (max+min)/2;
while(true){
if(target>arr[mid]){
min = mid+1;
}else if(target<arr[mid]){
max = mid -1;
}else{ //找到了元素
return mid;
}
//没有找到的情况
if (max<min){
return -1;
}
//重新计算中间索引值
mid = (min+max)/2;
}}
非递归(用while循环)
public static int search(int key,int[] arr){
int start=0;
int end=arr.length-1;
while(start<=end){
int mid=start+(end-start)/2;
if(key<arr[mid]){
end=mid-1;
}else if(key>arr[mid]){
start=mid+1;
}else{
return mid;
}
}
return -1;
}
递归
public static int search2(int key,int[] arr,int start,int end){
if(start >end){
return -1;
}
int mid=start+(end-start)/2;
if(key<arr[mid]){
return search2(key,arr,start,mid-1);
}else if(key>arr[mid]){
return search2(key,arr,mid+1,end);
}else{
return mid;
}
}

8.反转数组
public static void reverse(char[] arr){
for(int startIndex = 0 ,endIndex = arr.length-1 ; startIndex<endIndex ; startIndex++,endIndex–){
char temp = arr[startIndex];
arr[startIndex] = arr[endIndex];
arr[endIndex] = temp;
}
//遍历数组,查看效果
System.out.print(“目前的元素:”);
for (int i = 0 ; i<arr.length ;i++){
System.out.print(arr[i]+",");
}

}

9.Arrays数组工具的使用
数组的工具类(Arrays):
排序.sort(arr)
遍历输出.toString(arr)
.binarySearch(arr,key)二分查找法,找元素在数组中的位置
int[] arr = {12,3,1,10,8};
Arrays.sort(arr); //对数组进行排序
String info = Arrays.toString(arr); //输出数组元素
System.out.println(“数组的元素:”+ info);
// 1, 3, 8, 10, 12
int index = Arrays.binarySearch(arr,9);// 二分法查找 : 如果能在数组中找到对应 的元素,那么就返回该数据的索引值,如果没有找到那么就返回一个负数表示。
System.out.println(“找到的索引值:”+ index);

10.二维数组
二维数组就是数组中的数组
1.二维数组的定义格式:
数据类型[][]变量名 = new 数据类型[长度1][长度2];
2.二维数组的初始化方式:
动态初始化:
数据类型[][] 变量名 = new 数据类型[长度1][长度2];
静态初始化:
数据类型[][] 变量名 = {{元素1,元素2…},{元素1,元素2…},{元素1,元素2…} …}
3.遍历二维数组
Public static viod main(String[] args){
int[][] arr = {{10,11,9},{67,12},{33,35,39,40}};
For(int i=0;i<arr.length;i++){
For(int j=0;j<arr[i].length;j++){
System.out.println(arr[i][j]+”,”);
}
}
}
4.总结
数组的特点:
1. 数组只能存储同一种数据类型的数据
2. 数组是会给存储到数组中的元素分配一个索引值的,索引值从0开始,最大的索引值是length-1
3. 数组一旦初始化,长度固定
4. 数组中的元素与元素之间的内存地址是连续的

相关标签: java基础学习笔记