一、数组
1.概念：同一种数据类型的集合。（长度是固定的）
2.好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。
3.格式1:
元素类型[] 数组名 = new 元素类型[元素个数或数组长度] int [] arr = new int [8];
4.格式2:
元素类型[] 数组名 = new 元素类型[]{元素，元素，……} int [] arr = new int []{9,8,0,7,0};
5.格式3:
元素类型[] 数组名 = {}；int [] arr = {3,53,5,6,26};
6.new关键字，表示创建一个新的对象。
7.创建一个空的数组，虚拟机会自动给数组赋值为0。
8.赋值： 例：arr [0] = 8;
int [] arr = new int [] {2,5,8,0}
9.注意点：角标不能越界.
空指针异常：arr = null
10.java内存结构：
栈内存：用于存储函数中的局部变量，当数据用完时，所占空间会立即自动释放。
堆内存：对象和数组，通过new建立的实例都存放在当中。
本地方法区：
是jvm虚拟机调用系统使用的，应用层无法使用
寄存区：cpu运算时使用的内存块
11.数组的遍历：
int [] arr = {23,45,22,33,532,54,5};
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}![]()
13.排序
语法： Arrays.sort(数组名);
可以使用 sort( ) 方法实现对数组的排序，只要将数组名放在 sort( ) 方法的括号中，就可以完成对该数组的排序（按升序排列）
![]()
13. 将数组转换为字符串
语法： Arrays.toString(数组名);
可以使用 toString( ) 方法将一个数组转换成字符串，该方法按顺序把多个数组元素连接在一起，多个元素之间使用逗号和空格隔开
14.数组的扩容
语法：Arrays.copyOf(original, newLength)；
15.数组的复制
语法：System.arraycopy(src, srcPos, dest, destPos, length);
16.foreach
![]()
for(元素类型 元素变量：遍历对象){
执行的代码块
}
![]()
foreach获取脚标
public class ForEach {
public static void main(String[] args) {
String [] aaa = {"小花","小明","小绿","小白","小蓝","小猫咪","小狗狗"};
int i = 0;
for (String aa : aaa) {
System.out.println(aa + "["+i+"]");//+i为了输出脚标
i++;
}
}
}
17.如何对数组进行初始化
* a:
动态初始化只指定长度，由系统给出初始化值
* int[] arr = new int[5];
int []arr= {5,4,3,2,1};
动态初始化的
格式：
* 数据类型[] 数组名 = new 数据类型[数组长度];
* b:
静态初始化 给出初始化值，由系统决定长度
二、数组的应用
1.最大值：
public static int getMax(int[] arr) {
int tmp = arr[0];
int num = -1;
if (arr != null){
for (int i = 0; i < arr.length; i++) {
if (arr[i] > tmp) {
tmp = arr[i];
}
}return tmp;
}else return num;
}
2.冒泡排序：两数相比，将大的放后面，第一次循环后最
大的在最后面。
array[j] < array.length-1-i 防止脚标越界
public class Array01 {
public static void main(String[] args) {
int[] arr = { 2, 5, 3, 66, 4, 23, 62 };
maoPao(arr);
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
public static void maoPao(int[] array) {
int tem = 0;
if (array != null) {
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array.length - 1 - i; j++) {
if (array[j] > array[j + 1]) {
tem = array[j];
array[j] = array[j + 1];
array[j + 1] = tem;
}
}
}
}
}
}
public class Array02 {
public static void main(String[] args) {
int[] arr = { 23, 45, 22, 33, 532, 54, 5 };
xuanZhe(arr);
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
public static void xuanZhe(int[] arr) {
int tmp = 0;
if (arr != null) {
for (int i = 0; i < arr.length; i++) {
for (int j = i + 1; j < arr.length; j++) {
if (arr[i] > arr[j]) {
tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
}
}
}
}
}
public class HalfSearch {
public static void main(String[] args) {
int[] arr = { 2, 3, 5, 7, 13, 15, 33 };
search(arr, 33);
}
public static void search(int[] arr, int num) {
int begin = 0;
int index = 0;
int end = arr.length;
int middle = (begin + end) / 2;
if (arr != null) {
for (int i = 0; i < arr.length; i++) {
if (arr[middle] == num) {
index = middle;
} else if (arr[middle] > num) {
end = middle - 1;
middle = (begin + end) / 2;
} else {
begin = middle + 1;
middle = (begin + end) / 2;
}
}
System.out.println(index);
}
}
}
public class JibenSearch {
public static void main(String[] args) {
int[] arr = { 3, 4, 1, 45, 22, 44, 64, 6 };
System.out.println(search(arr, 1));
}
public static int search(int[] arr, int num) {
int index = -1;
if (arr != null) {
for (int i = 0; i < arr.length; i++) {
if (arr[i] == num) {
index = i;
break;
}
}
}
return index;
}
}
三、二维数组
1.格式：
格式1：inr[][] arr = new int [3][2];
*定义一个名称为arr 的二维数组
*二维数组中有3个一维数组
*每个一维数组中有2个元素
*一维数组的名称分别为arr[0],arr[1],arr[2]
*给第一个一维数组1脚标位赋值为5的写法是：arr[0][1] = 5;
格式2：inr[][] arr = new int [3][];
*每个一维数组中有3个一维数组
*每个一维数组都是默认初始化值null
*可以对这个三个一维数组分别初始化
arr[0] = new int [3]
arr[1] = new int [2]
arr[2] = new int [8]
格式3：inr[][] arr = {{2，5，3}，{9，3，4，2}，{0，3，4}};
*每个一维数组中有3个一维数组
*每一个二维数组中的具体元素都已经初始化
*第三个一维数组的长度 arr[2].length;
2.进值转换
import java.util.Scanner;
//10进制转16进制
public class ToHex {
public static void main(String[] args) {
System.out.println("请输入要转换的数：");
Scanner sc = new Scanner(System.in);
int number = sc.nextInt();
hex(number);
}
public static void hex(int num) {
char[] c = new char[8];
int index = 0;
while (num > 0) {
int tem = num & 15;// 将十进制的对应的二进制数每4位取出
if (tem > 9) {
c[index] = (char) ((tem - 10) + 'A');// 大于9输出字母
} else {
c[index] = (char) (tem + '0');// 小于9输出数字
}
index++;
num = num >>> 4;// 二进制数右移4位
}
for (int i = index - 1; i >= 0; i--) {// 倒序输出
System.out.print(c[i]);
}
}
}
public class LookTable {
public static void main(String[] args) {
search(60, 4, 15);
}
public static void search(int num, int a, int b) {
int index = 0;
int number = num;
char[] c = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };// 创建一个含数字和字母的数组
// 计算index 的长度
while (number > 0) {
number = number >>> a;
index++;
}
char[] arr = new char[index];// 创建新的数组用于存放得到数字和字母
// 从c 数组中找到对应的数存到arr 中
for (int i = 0; i < arr.length; i++) {
int tmp = num & b;
arr[i] = c[tmp];
num = num >>> a;
}
for (int i = arr.length - 1; i >= 0; i--) {// 将数组倒序输出
System.out.print(arr[i]);
}
}
}
四、递归（自己调自己）
1.递归是一种常见的解决问题的方法，即把问题逐渐简单化。它的思想就是
自己调用自己，一个使用递归技术的方法将会直接或间接调用自己。
2.递归结构包括两个部分：
定义递归头：解答：什么时候不调用自身方法，如果没有头，将会陷入死循环
定义递归体：
解答：什么时候调用自身方法。
3.算阶乘
import java.util.*;
public class DiGui {
public static void main(String[] args) {
System.out.println("请输入要算阶乘的数");
Scanner sc = new Scanner(System.in);//键盘录入要计算的数
int x = sc.nextInt();
int y = factorial(x);
System.out.println(y);
}
public static int factorial(int n){
if(n ==0){
return 1;
}else {
return n*factorial(n-1);//递归，调用方法本身
}
}
}
扫一扫
626
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
