2018-05-16 第十天

一、方法

(一)方法交换变量示意图

 

(二)方法重载overload

 

概念:在同一个类的内部,方法名字相同,参数列表不同,与返回类型无关的方法,称之为方法的重载。

 

方法名字相同:代表重载的方法实现的是类似的功能。

 

参数列表不同:参数的个数不同、参数的类型不同、顺序不同。

 

与返回类型无关:对于返回类型不是void 的方法,通常的用法是使用该方法参与某些计算的表达式。但是也可以直接调用,而不参与任何的运算。与返回类型是void 的直接调用的方式是有语义的冲突的。(保证方法的签名 signature 唯一性)。

 

二、数组array

 

)概念:数组是一个对象,是一个包含了一组变量的集合对象。这一组变量的类型必须一致。

 

初识数组:

1:数组是我们在java 中需要了解的第一种引用数据类型。

2:如何定义数组:申请内存空间的过程。

   语法:数组中变量的类型[]  数组变量名 = new 数组中变量的类型[变量的个数];

int[] scores = new int[10];

数组中的变量的类型 可以是 java 支持的任意类型。

boolean[] bools = new boolean[10];

3: 数组中的这一组变量的类型必须一致。

4:new 是一个java 关键字用来向 jvm 申请内存的。所有的变量的内存都是在堆中连续分配的。

5:通过new申请完内存之后,每一个数组内部的变量就有内存空间即每个变量就有值了!

每个变量在分配完空间之后,会由jvm 进行默认的初始化。

默认初始化的规则:变量类型是整数类型 = 0 -- char = '\u0000' -- float和double = 0.0 -- boolean = false -- 引用数据类型 = null.

6:数组中的变量被称之为数组元素 element。

7:如何访问数组元素:通过  数组名[元素序号]

8:数组中的每个元素都被默认赋予了一个顺序号。序号从0开始,是连续的,序号的专业名称:元素的下标、索引、角标(index)。数组的最小下标是 0 ,最大下标是[元素个数-1]。

9:数组对象包含了一个属性,一个int 类型的长度属性即元素的个数。通过  数组名.length 获得数组元素的个数。

10:数组变量名 一个引用(一种更加安全的地址)。

11:数组元素的个数一旦确定,那么就不能再更改了。数组是定长的。

 

(二)数组的初始化

数组初始化的方式:

1:动态初始化:

int[] scores = new int[10];

动态初始化就是在运行期通过 new 向jvm 动态的申请内存。jvm 会根据申请的内存的大小,在堆区中找一段连续的适合的大小的内存空间给数组元素使用。jvm 并对所有的元素进行默认初始化。

 

可以将声明 初始化分开进行。

int age;

age  =10;

 

int[] scores;

scores = new int[10];

 

2:静态初始化:

int[] scores = new int[]{1,2,3,54,6}; 元素的初始值 和  元素的个数 由大括号内的数值的个数来决定。

可以将声明 初始化分开进行。

int[] scores;

scores = new int[]{1,6,5,3};

适合元素数量比较少,元素的值通常是不再变化的。

 

3:静态初始化的其他的语法形式:

int[] scores = {56,7,8};

元素的个数和元素的初始值都由大括号内的数值决定。

限制:声明 赋值 必须在同时进行。必须一句代码完成。

 

数组声明的多种语法形式:

[]的位置可以在数据类型和数组名之间的任何位置,也可以在数组名之后

public static void testArray2(){

int[] values1 = new int[10];

int values2[] = new int[5];

int [] values3 = new int[6];

int  []values4 = new int[6];

}

 

 

(三)数组内存分配图

 

 

1:

public class TestArray1{

public static void main(String[] args){

testArray1();

}

// 随机得到 10个学生的分数[60~100],求学生分数的平均值 ,和 总分。

public static void testArray(){

final int COUNT = 10;

final int MIN = 60;

final int MAX = 101;

int sum = 0;

int avg = 0;

//使用for 循环得到是个随机的分数,累加到sum 上

for(int i=0;i<COUNT;i++){

int score = randomNumberByRange(MIN,MAX);

sum += score;

}

avg = sum/COUNT;

print("sum = "+sum);

print("avg = "+avg);

//还要查看每个学生具体的分数  定义多个变量保存多个学生的数据的方式 肯定不是最合适的选择。

//需求:如果一个变量 可以保存 任意个数据,那这个问题就解决了

}

public static void testArray1(){

final int COUNT = 10;

final int MIN = 60;

final int MAX = 101;

int sum = 0;

int avg = 0;

//定义数组  保存一组分数的变量

//申请COUNT 个 int 类型的变量空间。

int[] scores = new int[COUNT];

//使用for 循环得到是个随机的分数,累加到sum 上

//如何去访问每一个分数变量 : 通过  数组变量名[变量的序号(0~变量个数-1)]

for(int i=0;i<COUNT;i++){

//对每个数组中的分数变量赋值。

scores[i] = randomNumberByRange(MIN,MAX);

sum += scores[i];

}

avg = sum/COUNT;

print("sum = "+sum);

print("avg = "+avg);

//打印每个数组中的分数变量的值。

for(int i=0;i<COUNT;i++){

print("第 "+(i+1)+" 个学生的分数为:"+scores[i]);

}

}

public static void print(String str){

System.out.println(str);

}

public static int randomNumberByRange(int min, int max){

return (int)(Math.random()*(max-min)+min);

}

}

 

2:

//定义一个boolean类型的数组,动态初始化,长度随机[5-10];并打印输出数组的长度。然后对数组元素随机赋值 Random提供的nextBoolean 方法。

//遍历输出数组的元素的内容。 上述内容,在一个自定义的方法内实现。

public static void testBooleanArray(){

final int MIN = 5;

final int MAX = 11;

int length = randomNumberByRange(MIN, MAX);

System.out.println("length = "+length);

boolean[] bools = new boolean[length];

Random random = new Random();

//使用for 循环对数组元素逐一赋值

for(int i=0;i<bools.length;i++){

bools[i] = random.nextBoolean();

}

for(int i=0;i<bools.length;i++){

System.out.print(bools[i] + "\t");

}

}

 

3:

//写一个方法:功能要求:定义一个byte类型的数组,长度为5,静态初始化,元素的数值要求随机,范围[0-100],最后遍历输出数组的内容。

public static void testByteArray(){

final int MIN = 0;

final int MAX = 101;

byte[] values = {

(byte)randomNumberByRange(MIN, MAX),

(byte)randomNumberByRange(MIN, MAX),

(byte)randomNumberByRange(MIN, MAX),

(byte)randomNumberByRange(MIN, MAX),

(byte)randomNumberByRange(MIN, MAX)

};

for(int i=0;i<values.length;i++){

print("\t"+values[i]);

}

}

 

4:

// 1:定义一个方法,根据给定的长度,动态初始化一个int类型元素数组,然后对元素随机赋值 根据给定的区间。并返回该数组  就是返回数组变量。

// 2:通过上面的方法,得到一个数组之后,再自定一个方法,对给定的数组,求出该数组中存在内容为指定值 的元素的数量。

// 有多少个元素和指定的值相同,,最后输出结果。

// 3:方法要求:将指定数组元素的内容为指定值的索引(数组下标)全部返回。返回一个数组,数组中包含的是指定数组的元素的索引值。

public class TestArray2{

public static void main(String[] args){

int[] arr = getRandomArray(6, 0, 17);

printArray(arr);

int key = 6;

int count = getEleCountByKey(arr , key);

print("数组中元素值为:"+ key + " 的元素的数量为:"+count);

int[] indexes = getEleIndexesByKey(arr, key);

printArray(indexes);

}

// 1:定义一个方法,根据给定的长度,动态初始化一个int类型元素数组,然后对元素随机赋值 根据给定的区间。并返回该数组  就是返回数组变量。

public static int[] getRandomArray(int length, int min, int max){

//动态初始化一个int类型的数组

int[] arr = new int[length];

//对数组元素随机赋值

for(int i=0;i<length;i++){

arr[i] = randomNumberByRange(min, max);

}

//返回得到的数组

return arr;

}

// 2:通过上面的方法,得到一个数组之后,再自定一个方法,对给定的数组,求出该数组中存在内容为指定值 的元素的数量。

public static int getEleCountByKey(int[] arr, int key){

//定义计数器

int counter = 0;

//遍历数组元素,逐个使用key 和每一个元素比较,相等的话  计数器加一

for(int i= 0;i < arr.length ; i++){

if(arr[i] == key){

counter ++;

}

}

//最后返回计数器

return counter;

}

//求 arr 中 所有的元素 和 key 值相等的 元素下标的集合

public static int[] getEleIndexesByKey(int[] arr, int key){

//定义数组用来保存 满足条件的 数组元素的下标

int count = getEleCountByKey(arr, key);

int[] indexes = new int[count];

//遍历数组,将满足条件的元素的下标依次保存到指定的数组中

//定义用来标记当前数组下标的变量

int index = 0;

for(int i=0;i<arr.length;i++){

if(arr[i] == key){

//每放入一个元素,用于记录下标的变量自增一次,下次再放元素的时候,放到下一个还没存放下标的元素的位置

indexes[index++] = i;

// index ++;

}

}

//最后返回数组

return indexes;

}

//自定义方法,实现对int 类型的数组的内容的打印[1, 3, 5, 8]

public static void printArray(int[] array){

//如果数组的长度为0 ,那么就打印一对空的[]

if(array.length == 0){

print("[]");

return;

}

System.out.print("[");

//最后一个元素不打印

for(int i=0;i<array.length-1;i++){

System.out.print(array[i] + ", ");

}

//单独打印最后一个元素

System.out.print(array[array.length-1]+"]\n");

}

public static int randomNumberByRange(int min, int max){

return (int)(Math.random()*(max-min)+min);

}

public static void print(String str){

System.out.println(str);

}

}

 

5:

//自定义方法实现对任意的int 类型元素的数组,求出该数组的最大值

public static int max(int[] arr){

int max = arr[0];

//将元素的最大值 赋值  给 max

for(int i=1;i<arr.length;i++){

// 如果元素的值 大于 max 就把元素的值赋值给max

if(arr[i] > max){

max = arr[i];

}

}

return max;

}

 

(四)数组作为参数交换元素的值的内存图

 

 

(1)数组删除元素

//删除元素 (指定下标):直接在源数组上删除。后续的元素需要整体前移。(最后的元素不需要处理)。 最后返回数组的有效数据的个数。

public static int removeElementByIndex(int[] srcArr , int removeIndex){

// 源数组 堆内存都没有空间

if(srcArr == null){

return -1;

}

int len = srcArr.length;

//元素长度为0

if(len == 0){

return 0;

}

//removeIndex 不在区间之内

if(removeIndex < 0 || removeIndex > len -1){

return -2;

}

//逐个移位

for(int i= removeIndex + 1; i < len ;i++){

//将当前i 的位置上的元素的值 赋值给 它前面的一个元素的值 i-1

srcArr[i-1] = srcArr[i];

}

return len-1;

}

 

(2)数组插入元素

//在指定的索引处的插入一个元素。该位置的原来的元素和后续的所有的元素整体后移。挤掉最后一个元素

public static void insertValueByIndex(int[] arr, int insertIndex, int insertValue){

//逐个将插入的位置的元素逐个后移  逆序移动

for(int i= arr.length-2 ;i >= insertIndex;i--){

arr[i+1] = arr[i];

}

//将插入的数据放到指定的位置

arr[insertIndex] = insertValue;

}

 

(3)增强for循环(for -- each)

增强的for 循环:for-each(jdk1.5 版本之后

 

作用:用来遍历容器的。可以用来遍历数组。只能用来遍历元素,不能用来修改元素的值。

使用增强的for 循环访问的数组的数据,都是源数组的元素的拷贝。

 

语法:

int[] arr = new int[10];

for(int value : arr){

}

for(int i=0;i<arr.length;i++){

arr[i]

}

 

arr 是被遍历的数组。

value 是循环每迭代一次,从arr 中顺序的取出的元素的值。

 

总结:增强的for 循环其实没有增强,反而功能被削弱了!

for-each 只能用来遍历数组,不能在循环中修改元素的值。

好处:语法相对简单了一点。

 

public static void printArrayForEach(int[] array){

//如果数组的长度为0 ,那么就打印一对空的[]

if(array.length == 0){

print("[]");

return;

}

System.out.print("[");

for(int value : array){

System.out.print(value + ", ");

}

System.out.print("]\n");

}

 



阅读更多
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭