第四篇
·数组:
1.概念:一组相同类型的数据的组合
数组也是一种引用类型,
2.名称:数组名称不是固定的,与存放的数据的类型有关。
如: 存放一组int类型的数据,
数组名称 int[]
存放一组字符串数据
数组名称 String[]
存放一组Scanner类型的数据
数组名称 Scanner[]
存放一组字符类型的数据
数组名称 char[]
3.元素的概念:数组中的每个数据,都是这个数值的元素。
4.数组的声明与初始化
声明:元素类型[] 变量名;
元素类型 变量名[];--不建议此写法
变量的初始化的时机:2种
(1)声明时直接初始化
(2)先声明,再初始化(使用前初始化)
数组的变量初始化:3种情况
(1)静态初始化
String[] names = {"A","B"};
int[] nums = {};
(2)动态初始化
--规定数组长度的写法
int[] ages = new int[length];
其实有默认元素:
整数类型:默认是0
浮点数类型:默认0.0
字符类型:默认'\u0000'
布尔类型:默认false
引用数据类型:默认值null
--不规定长度的写法
int[] ages = new int[]{};
double[] counts = new double[]{1.2,3.14};
5.数组的长度:
即数组元素的个数
表示方式:变量名.length;
6.数组的下标(index):
下标从0开始,最后一个元素的下标为:length-1;
下标范围:0~length-1
7.数组元素的访问(查看):
通过下标进行查看
语法:变量名[index];
元素的遍历(从头到尾依次查看)
for(int i=0;i<变量名.length;i++){
System.out.println(变量名[i]);
}
8.数组元素的覆盖(赋值,替换)
语法:变量名[index] = value;
9.数组间的赋值:就是指变量之间的赋值。
通过一个变量对数组的元素进行修改,那么与之相关的变量对应的数组的元素也会发生相应变化
10.数组下标越界异常:
java.lang.ArrayIndexOutOfBoundsException
出现的原因:访问数组元素时的下标超出了范围
正确范围:0~length-1
错误下标:
变量名[-1]
变量名[length]
3.引用类型之Arrays
是数组的工具类。此类提供了很多对数组操作的功能方法
如:
String info = Arrays.toString(数组名);
Arrays.toString():此方法是将数组的元素一一拼接成字符串.
格式如下:
"[元素1,元素2,.....元素length-1]"
数组的特点:一经创建,长度不可变
数组的复制
系统复制法:
System.arraycopy(src,start1,des,start2,length);
src:源数组,即被复制的数组名
start1:源数组复制的开始下标
des:目标数组,即复制到的数组名
start2:目标数组复制的开始下标
length:复制的长度
工具类提供的复制方法:
元素类型[] 变量名=Arrays.copyOf(src,newLength);
src:源数组
newLength:新数组的长度
功能解释:从src的下标为0的元素开始复制,复制到长度为newLength的新数组中,新数组存放元素的开始位置为0
数组的排序:
冒泡排序的基本思想:
在要排序的数组中,对当前还未排好序的范围内的全部数,自上而下(自左到右)对相邻的两个数依次进行比较和调整,让较大的往下沉(或向右移),较小的往上冒(或向左移)。
即:每当两相邻的数比较后他们的顺序与排序要求相反时,就将他们互换。
冒泡排序的改进:
对冒泡排序的常见的改进方法是: 加入一个标志性的变量,用于标志某一轮排序过程中是否有数据交换,如果没有进行数据交换,则说明数据已经按照要求排列好,可立即结束排序,避免不必要的比较过程。
冒泡排序的每一步详情
第一轮:找最大值
4>5 false {4,5,2,3,1}
5>2 true {4,2,5,3,1}
5>3 true {4,2,3,5,1}
5>1 true {4,2,3,1,5}--排出5
第二轮:找第二大
4>2 true {2,4,3,1,5}
4>3 true {2,3,4,1,5}
4>1 true {2,3,1,4,5}--排出4
第三轮:找第三大
2>3 false {2,3,1,4,5}
3>1 true {2,1,3,4,5}--排出3
第四轮:找第四大
2>1 true {1,2,3,4,5}--排出2
简单选择排序:
基本思想如下
在要排序的数组中,选择出最小(或者最大)的一个数与第一个位置的数交换,然后再剩下的数当中再找最小(或最大)的与第二个位置的数交换依次类推,直到第n-1个元素(倒数第二个)和第n个元素(最后一个数)比较为止。
简单选择排序
原始数据 {4,5,2,3,1};
找出最小1 与4交换 {1,5,2,3,4}
找出最小2 与5交换 {1,2,5,3,4}
找出最小3 与5交换 {1,2,3,5,4}
找出最小4 与5交换 {1,2,3,4,5}
工具类Arrays里的排序方法:
Arrays.sort(数组名):对基本数据类型的数组与引用类型的数组都可排序
二维数组
概念:数组的元素依然是数组
int[] a = {1,2,3,4}
int[][] b={{1,2},{2,3,4,5,6},{1,2,3}}
访问: b[0]-->{1,2}
b[1]-->{2,3,4,5,6}
b[2]-->{1,2,3}
b[0][0] -->1
b[0][1] -->2
.....
b[1][3] -->5
b[1][4] -->6
...
b[2][1] -->2
x={ ·
{1,2,3},
{1,2,3},
{4,5,6}
}
x数组的元素:都是等长的数组,类似于矩阵。
y ={
{1,2},
{1,2,3},
{1}
}
y数组的元素:不是等长的数组。
二维数组的初始化:
静态初始化
如:int[][] a = {{1},{1,2},{2,3,4}};
动态初始化
(1)等长式初始化
int[][] a = new int[3][2];
表示a有三个元素,每个元素都是2个长度的数组。
(2)只规定高维数组的长度
int[][] a = new int[3][];
表示a有三个元素,但是都是null.
null在使用时,需要新建数组对象(长度任意)
=================================================================
第五篇
方法:即功能,封装了一段逻辑代码。
方法的定义:
固定语法:
修饰词 返回值类型 方法名(形式参数){
逻辑代码
}
方法的位置:
在类体中,与main方法是并列关系,类体中可以有多个方法。
修饰词:
(1)public--公共的
(2)protected--受保护的
(3)private --私有的
也可以不写修饰词,即默认的(default)
static修饰词可以与上述三个连用
返回值类型:
(1) void---无返回值类型
(2)java语言的任意一种类型
可以是基本数据类型,也可以是引用数据类型
方法名:
命名时尽量做到见名知意,驼峰命名法,首字母小写
形式参数:
用于接收调用者传入的数据。与变量的声明语法相同。
关键字return:
作用1:结束方法逻辑
作用2:如果返回值类型标记的是java语言类型的某一个类型名,那么return关键字后必须跟着一个此类型的数据或变量。
当方法有返回值类型时,return关键字后的数据就是此方法要返回的数据。返回给调用者。
如:
int num = Math.random();
方法random()返回一个数据给main方法。main方法存入num变量中
如:
reg1:
public static void sum(){
int a = 3;
int b = 5;
System.out.println(a+b);
[return;]---返回值类型处写void时,return可有可无;
}
reg2: 计算两个整数a和b的和
public static void sum(int a,int b){
int sum = a+b;
System.out.println(sum);
}
PS: 方法定义期间,就是制定逻辑流程模板。
reg3:
public static int sum(){
int a = 3;
int b = 5;
int sum = a+b;
return sum;
}
reg4:
public static int sum(int a,int b){
int sum = a + b;
return sum*3;
}
方法的调用,即使用
reg1如何使用:
main(String[] args){
sum();
}
reg2如何使用:
main(String[] args){
/*
调用者main 在使用sum(int a,int b)时,需要给形式参数赋值,赋的值叫实际参数
*/
int x = 1;
int y = 2;
sum(x,y);
}
reg3如何使用
main(String[] args){
int n = sum();
}
reg4如何使用
main(String[] args){
int m = 10;
int n = 20;
int s = sum(m,n);
}
总结:
调用方法:
无返回值时:
方法名(有参就传参);
有返回值时:
返回值类型 变量=方法名(有参就传参);