目录
4.3实现一个方法 avg, 以数组为参数, 求数组中所有元素的平均值(注意方法的返回值类型).
4.6实现一个方法 toString, 把一个整型数组转换成字符串. 例如数组 {1, 2, 3} , 返回的字符串为 "[1, 2, 3]", 注意 逗号 的位置和数量.
4.7给定一个整数数组 nums 和一个整数目标值 target,请你在该数组中找出 和为目标值 target 的那 两个 整数,并返回它们的数组下标。
4.8给你一个整数数组 arr,请你判断数组中是否存在连续三个元素都是奇数的情况:如果存在,请返回 true ;否则,返回 false 。
1.数组的基本用法
1.1什么是数组
数组的本质就是让我们能批量创建相同类型的变量。注:在Java中,数组中包含的变量必须是相同类型。
1.2创建数组
基本语法
//动态初始化
数据类型[ ]数组名称 = new 数据类型[ ]{初始化数据};
//静态初始化
数据类型[ ]数组名称 = { 初始化数据};
注:静态初始化的时候,数组元素的个数和初始化数据的格式是一致的。
1.3数组的使用
1.获取一个数组的长度:使用数组名称 .length
//获取数组的长度 int[] arr = {1,2,3}; System.out.println(arr.length);//运行结果:3
2.如何访问数组元素:使用数组名称[要访问的元素相较于第一个元素的偏移量]
int[] arr = {1,2,3}; System.out.println(arr[0]);//运行结果:1 System.out.println(arr[2]);//运行结果:3
数组的索引是从0开始,最后一个元素的索引是.length - 1;
3. 如果访问数组中并不存在的元素会怎么样?
int[] arr = {1,2,3}; System.out.println(arr[3]);
//运行结果
访问了一个非法索引,这个索引在当前数组中根本不存在,超出了最大索引,下表越界。
1.4数组的遍历
遍历一个数组,可以用for循环,在JDK1.8中引入的一个for-each循环,叫增强型for循环。
for(int i :arr){
System.out.print(i + " ");
}
此处的i指的是从数组第一个元素开始取值,第一次把第一个元素的复制一份给i,第二次把第二个元素的值复制一份给i,一次类推,直到整个数组都遍历。(只能读取数组的值,不能修改数组的值,每次都把元素的值复制给i)
int[] arr = {1,2,3};
for (int i:arr){
System.out.println(i + " ");
}
//运行结果
1
2
3
2.数组作为方法的参数
2.1 用方法打印数组
public static void main(String[] args) {
int[] a = {1, 2, 3};
sum(a);
}
public static void sum(int[] arr) {
for (int i : arr) {
System.out.println(i + " ");
}
}
//运行结果
1
2
3
在这里 ,int[] a是函数的实参,int[] arr是函数的形参。
2.2理解引用类型
参数传内置类型
public class Practice {
public static void main(String[] args) {
int num = 0;
sum(num);
//调用sum()方法,把num的值赋给arr。
System.out.println("num ="+ num);
}
//arr的值为0,没有返回值的方法。
public static void sum(int arr) {
//把10赋值给arr。
arr = 10;
System.out.println("arr = "+ arr);
}
}
//运行结果
arr = 10
num =0
参数传数组类型
public class Practice {
public static void main(String[] args) {
int[] num = {1,2,3,4};
sum(num);
//调用sum()方法,把数组num的值赋给数组arr。
System.out.println("num[0] ="+ num[0]);
}
//arr[0]的值为1,没有返回值的方法。
public static void sum(int[] arr) {
//把10赋值给arr[0]。
arr[0] = 10;
System.out.println("arr[0] = "+ arr[0]);
}
}
//运行结果
arr[0] = 10
num[0] =10
在函数内部修改数组内容,函数内外部也发生了改变,此时数组名num是一个“引用”,当传参的时候,是按照引用传参。
int[] num = new int[]{1,2,3}
1.当我们创建new int[]{1,2,3}的时候,相当于创建了一块内存空间保存三个int。
2.接下来执行int[] num = new int[]{1,2,3} 相当于又创建了一个int[]变量,这个变量是一个引用类型,里面只保存了一个整数(数组的起始内存地址)
3.传参相当于int[] num = arr,我们修改num[0],此时是把num的首地址给到arr,则arr的首地址就受到了更改,本质上就是arr[0]获取了num[0]地址上的数据。
2.3堆和栈
栈:程序每次调用的过程中就对应一个栈帧的入栈和出栈,当方法开始调用时,入栈,方法中的局部变量都在占中保存,当方法结束调用时,出栈,所有的局部变量就会销毁。
堆:看到关键字new,new出来的对象都在堆中保存。
3.数组作为返回值
3.1写一个方法,将数组中的每一个元素都乘2
public class Xiugai {
public static void main(String[] args) {
int[] arr = new int[]{1,2,3};
transform(arr);
}
public static void transform(int [] num){
for (int i = 0; i < num.length; i++) {
num[i] = num[i] * 2;
System.out.print(num[i]+"\t");
}
}
}
//运行结果
2 4 6
这个代码固然可行,但是破坏了原有数组,有时候我们不希望破坏原有数组,就需要在方法内部创建一个新的数组,并有方法返回出来。
public class Xiugai {
public static void main(String[] args) {
int[] arr = new int[]{1,2,3};
int[] arr1 = transform(arr);
}
public static int[] transform(int [] num){
int[] ret = new int[num.length];
for (int i = 0; i < num.length; i++) {
num[i] = num[i] * 2;
System.out.print(num[i]+"\t");
}
return ret;
}
}
//运行结果
2 4 6
这样的话就不会破坏原有数组了,由于数组是引用数据类型,返回的时候只是将这个数组的首地址返回给函数调用者,没有拷贝数组内容,从而比较高效。
4.数组练习
4.1数组转字符串
在某些类后加s,这种类就是jdk中的工具类,提供了大量的方法,直接调用数组的工具类,包含数组转字符串的方法,数组排序的方法,等操作都在类中,直接拿来使用。
import java.util.Arrays;
public class Practice {
public static void main(String[] args) {
int[] num = {1, 2, 3, 4};
System.out.println(Arrays.toString(num));
}
}
//运行结果
[1, 2, 3, 4]
Arrays.toString( )是遍历数组的工具类。
4.2用二分法查找数组中的元素的索引
public class ChaZhao {
public static void main(String[] args) {
int[] data = {1, 2, 3, 4, 5, 6};
System.out.println(sum(data, 6));
System.out.println(sum(data, 5));
System.out.println(sum(data,8));
}
public static int sum(int[] arr, int toFind) {
int left = 0;
int right = arr.length - 1;
while (left <= right) {
int mid = (left + right) / 2;
if (toFind < arr[mid]) {
right = mid - 1;
} else if (toFind > arr[mid]) {
left = mid + 1;
} else {
System.out.println("找到元素");
return mid;
}
}
System.out.println("未找到元素");
return -1;
}
}
//运行结果
找到元素
5
找到元素
4
未找到元素
-1
4.3实现一个方法 avg, 以数组为参数, 求数组中所有元素的平均值(注意方法的返回值类型).
public class ShuZuHeJunZhi {
public static void main(String[] args) {
int[] num = {2,3,4};
avg(num);
System.out.println(avg(num));
}
public static double avg(int[] arr){
int sum = 0;
for (int i = 0; i < arr.length ; i++) {
sum += arr[i] ;
}
return sum /(double) arr.length;
}
}
//运行结果
3.0
4.4给定一个整型数组, 实现冒泡排序(升序排序)
import java.util.Arrays;
public class MaoPaoFa {
public static void main(String[] args) {
int[] x = new int[]{1,4,5,2,3,6,7};
sum(x);
System.out.println(Arrays.toString(x));
}
public static void sum(int[] arr){
for (int i = 0; i < arr.length -1; i++) {
boolean num = false;
for (int j = 0; j < arr.length - i - 1; j++) {
if(arr[j] > arr[j + 1]){
num = true;
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
if(!num){
break;
}
}
}
}
//运行结果
[1, 2, 3, 4, 5, 6, 7]
4.5给定一个整型数组, 判定数组是否有序(递增)
public class YouXu {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 6};
int[] arr1 = {1,3,2,4,5};
sum(arr);
sum(arr1);
}
public static Boolean sum(int[] num) {
for (int i = 0; i < num.length - 1; i++) {
if (num[i] > num[i + 1]) {
System.out.println("数组无序");
return false;
}
}
System.out.println("数组有序");
return true;
}
}
//运行结果
数组有序
数组无序
4.6实现一个方法 toString, 把一个整型数组转换成字符串. 例如数组 {1, 2, 3} , 返回的字符串为 "[1, 2, 3]", 注意 逗号 的位置和数量.
public class ZhuanZiFu {
public static void main(String[] args) {
int[] arr = {1,2,3};
System.out.println(toString(arr));
}
public static String toString(int[] arr){
String ret = "[";
for (int i = 0; i < arr.length; i++) {
ret += arr[i];
if (i != arr.length - 1){
ret += ",";
}
}
ret += "]";
return ret;
}
}
//运行结果
[1,2,3]
4.7给定一个整数数组 nums 和一个整数目标值 target,请你在该数组中找出 和为目标值 target 的那 两个 整数,并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是,数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
示例 1:
输入:nums = [2,7,11,15], target = 9
输出:[0,1]
解释:因为 nums[0] + nums[1] == 9 ,返回 [0, 1] 。
import java.util.Arrays;
public class XiaBiao {
public static void main(String[] args) {
int[] sums = {2,7,11,15};
sum(sums,26);
}
public static int[] sum(int[] arr,int target){
int [] num = new int[2];
for (int i = 0; i < arr.length; i++) {
for (int j = i + 1; j < arr.length; j++) {
if (target == arr[i] + arr[j]){
num[0] = i;
num[1] = j;
}
}
}
System.out.println(Arrays.toString(num));
return num;
}
}
//运行结果
[2,3]
4.8给你一个整数数组 arr
,请你判断数组中是否存在连续三个元素都是奇数的情况:如果存在,请返回 true
;否则,返回 false
。
import java.util.Arrays;
public class LianXuJiShu {
public static void main(String[] args) {
int[] arr = {1,2,4,5,6,8,5,7,9};
int[] arr1 = {1,2,3,4,5,6,7,8,8};
sum(arr);
sum(arr1);
}
public static int[] sum(int[] arr){
int[] ret = new int[3];
int count = 0;
for (int i = 0; i < arr.length - 2; i++) {
if (arr[i] % 2 != 0 && arr[i + 1] % 2 != 0 && arr[i + 2] % 2 != 0){
ret[0] = arr[i];
ret[1] = arr[i + 1];
ret[2] = arr[i + 2];
count++;
}
} if(count >= 1){
System.out.println(true);
System.out.println(Arrays.toString(ret));
return ret;
}else {
System.out.println(false);
}
return ret;
}
}
//运行结果
true
[5, 7, 9]
false
5.每日一汤
这个世界并不美好,所以美好是值的我们去追求的。人生有很多的哭泣,所以笑看人生才值的去努力。人是有很多缺陷的,但是我希望能有一种力量可以帮助我,诚实的面对自己,认识自己的有限,自己的愚蠢,自己的幽暗,能够靠着这种力量,能够每天活在一种坦然和不愧中,在自己的使命中,能够超越这种虚荣和虚无。