（一）、总结
一、数组的定义
1、数组主要解决多变量多数据的存储问题，方便程序后期统一维护操作数据
2、数组就是一系列空间大小相等且地址连续的一片存储空间，大小相等是为了方便统一维护我们的数据，必须得保证数据之间的类型是一样的。地址连续是就是为了方便统一操作我们的数据。
二、数组的声明
为了在程序中使用数组
，
必须声明一个引用数组的变量
，
并指明数组的元索类型
。
下面
是声明数组变量的语法
：
1、创建数组只指定长度但不指定内容：
数据类型[] 数组名=new 数据类型[长度];
2、创建数组指定内容(指定长度)
数据类型[] 数组名=new 数据类型[]{1,2,3,4,5}；
数据类型[] 数组名={1,2,3,4,5};
3、[]与[][]的区别
[]表示是一维数组
[][]表示二维数组
4、示例
三、处理数组
1、处理数组元素时，经常会用到 for 循环，理由有以下两点：
1
)
数组中所有元素都是同一类型的
。
可以使用循环以同样的方式反复处理这些元素
。
2
)
由于数组的大小是已知的
，
所以很自然地就使用
for
循环
2、处理时常见的错误：
1）、 数组角标越界：ArrayIndexOutOfBoundsException
2）、 空指针异常：NullPointerException
四、数组的查找
1、分类：
1）、线性查找法
2）、二分查找法
2、线性查找法：
1）、线性查找的步骤
线性査找法将要査找的关键字
key
与数组中的元素逐个进行比较
。
这个过程持续到在列
表中找到与关键字匹配的元素
，
或者査完列表也没有找到关键字为止
。
如果匹配成功
，
线性
査找法返回与关键字匹配的元素在数组中的下标
。
如果没有匹配成功
，
则返回
-
1
。
2）、线性查找的特点
线性査找法把关键字和数组中的每一个元素进行比较
。
数组中的元素可以按任意顺序排
列
。
平均来看
，
如果关键字存在
，
那么在找到关键字之前
，
这种算法必须与数组中一半的元
素进行比较
。
由于线性査找法的执行时间随着数组元素个数的增长而线性增长
，
所以
，
对于
大数组而言
，
线性査找法的效率并不高
。
3、二分查找法
1）、二分查找步骤
二分査找法是另一种常见的对数值列表的査找方法
。
使用二分査找法的前提条件是数组
中的元素必须已经排好序
。
假设数组已按升序排列
。
二分査找法首先将关键字与数组的中间
元素进行比较
。
考虑下面三种情况
：
1）、如果关键字小于中间元素
，
只需要在数组的前一半元素中继续査找关键字
。
2）、如果关键字和中间元素相等
，
则匹配成功
，
査找结束
。
3）、如果关键字大于中间元素
，
只需要在数组的后一半元素中继续査找关键字
2）、二分查找的特点
二分查找法的效率较高
，
但它要求數组已经排好序
。
五、数组的排序
方法：
1、选择排序：
当前元素和之后所以元素进行比较，如果当前大于后者，则交换
public static void selectSort(){
int[] arr={8,5,9,2,7,4,6,1,3};
for(int i=0;i<arr.length-1;i++){//-1是因为没有必要进行最后一个数字的比较
for(int j=i+1;j<arr.length;j++){
if(arr[i]>arr[j]){
swap(arr,i,j);//即用-即释放
}
}
}
show(arr);
public static void swap(int[] arr,int i,int j){
arr[i]=arr[i]+arr[j];
arr[j]=arr[i]-arr[j];
arr[i]=arr[i]-arr[j];
}
public static void show(int[] arr){
String s="[";
for(int i=0;i<arr.length;i++){
if(i==arr.length-1){
s+=arr[i]+"]";
}else{
s+=arr[i]+",";
}
}
System.out.println(s);
}
2、冒泡排序
从左往右依次进行比较
public static void bubbleSort(){
int[] arr={8,5,9,2,7,4,6,1,3};
for(int i=0;i<arr.length-1;i++){//-1是少一轮比较
for(int j=0;j<arr.length-1-i;j++){//-1避免重复比较和角标越界
if(arr[j]>arr[j+1]){
swap(arr,j,j+1);
}
}
}
show(arr);
}
public static void swap(int[] arr,int i,int j){
arr[i]=arr[i]+arr[j];
arr[j]=arr[i]-arr[j];
arr[i]=arr[i]-arr[j];
}
public static void show(int[] arr){
String s="[";
for(int i=0;i<arr.length;i++){
if(i==arr.length-1){
s+=arr[i]+"]";
}else{
s+=arr[i]+",";
}
}
System.out.println(s);
}
3、插入排序
如果当前的数字的左边有数字且左边的数字大于当前的数字，则交换
public static void insertSort(){
int[] arr={8,5,9,2,7,4,6,1,3};
int e;
int j;
for(int i=1;i<arr.length;i++){
e=arr[i];
for(j=i;j>0&&arr[j-1]>e;j--){
arr[j]=arr[j-1];
}
arr[j]=e;
}
show(arr);
}
public static void show(int[] arr){
String s="[";
for(int i=0;i<arr.length;i++){
if(i==arr.length-1){
s+=arr[i]+"]";
}else{
s+=arr[i]+",";
}
}
System.out.println(s);
}
4、计数排序
将数字和角标进行规整，是典型的牺牲空间换取时间的排序
public static void countSort(){
int[] arr={8,5,9,2,7,4,6,1,3,10,-3,-2,-10};
int min=arr[0];
int max=arr[0];
for(int i=0;i<arr.length;i++){//O(n)
if(arr[i]>max){
max=arr[i];
}
if(arr[i]<min){
min=arr[i];
}
}
int[] nums=new int[max-min+1];
int offset=min;
for(int i=0;i<arr.length;i++){//O(n)
nums[arr[i]-offset]++;
}
int index=0;
for(int i=0;i<nums.length;i++){//O(m)
if(nums[i]!=0){
for(int j=0;j<nums[i];j++){
arr[index++]=i+offset;
}
}
}
show(arr);
}
public static void show(int[] arr){
String s="[";
for(int i=0;i<arr.length;i++){
if(i==arr.length-1){
s+=arr[i]+"]";
}else{
s+=arr[i]+",";
}
}
System.out.println(s);
}六、二维数组
1、二维数组的定义
是一个由行和列组成的一个表格，在这个矩阵中访问元素的话，是根据元素的行角标和列角标所确定的
2、二维数组在内存中是如何存储的
无论是二维数组，还是多维数组，它们本身就是一个一维数组，对于二维数组而言，无非就是一个一维数组，只不过该一维数组中的每一个元素是另一个一维数组
3、二维数组的创建
1）、int[][] matrix=new int[num][num]; //先定义，二维数组内为空
/*
int为二维数组的存储类型
num决定二维数组的大小
*/
2）、int[][] matrix=new int[][]{{1,2,3,4} ,{5,6,7,8} ,{9,10,11,12} };//定义同时在二维数组中存储数据
3）、锯齿矩阵/二维数组
int[][] matrix={ {1,2,3,4} , {5,6,7} , {8,9}, {10} };
七、部分零碎点
1、foreach 循环 （一个简化过后的for循环）
结构：
for(循环数据类型 循环变量名 : 可迭代对象 ){
循环体；
}
2、Arrays 类（数组工具类）
常用：
1）、static int binarySearch(int[] a, int key)
2）、static void sort(int[] a)
3）、static int[] copyOf(int[] original, int newLength)
4）、static String toString(int[] a)
5）、static boolean equals(int[] a, int[] a2)
3、多返回值处理
Java的函数仅仅只能返回单一的值，当需要返回多个返回值时，可以将个值封装在一个数组当中即可
（二）、习题
1、
final static int NUM =10;
import java.util.Scanner;
class Home5_2{
public static void main(String[] args) {
int []array = new int [NUM];
Input(array);
Output(array);
}
public static void Input(int []arr) {
Scanner input = new Scanner(System.in);
System.out.print("Etner the numbers：");
for(int i =0;i<NUM;i++) {
arr[i]= input.nextInt();
}
}
public static void Output(int [] arr) {
int count =0;
for(int i = 0;i<NUM;i++) {
for(int j =i+1;j<NUM;j++) {
if(arr[i]==arr[j])
arr[i]=-1;
}
if(arr[i]!=-1)
count++;
}
System.out.print("The number of distinct number is "+count+"\n");
for(int i=0;i<NUM;i++) {
if(arr[i]!=-1)
System.out.print(arr[i]+" ");
}
}
}
2、
import java.util.Scanner;
class Home5_3{
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("Enter lits");
int num = input.nextInt();
int []list = new int [num];
for(int i =0;i<num;i++) {
list[i]=input.nextInt();
}
if(isSorted(list))
System.out.println("Tht list is alreaday sroted!");
else
System.out.println("The list isn't sorted!");
}
public static boolean isSorted(int [] list) {
for(int i =0;i<list.length;i++) {
for(int j =i+1;j<list.length;j++) {
if(list[i]>list[j])
return false;
}
}
return true;
}
}3、
import java.util.*;
class Home5_4{
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
System.out.print("Enter the number of balls to drop:");
int balls=scanner.nextInt();
System.out.print("Enter the number of slots in the bean machine:");
int slots=scanner.nextInt();
int[] arr=new int[slots];
//3.几个球几个路径path
for(int i=0;i<balls;i++){
String path=getPath(slots);
System.out.println(path);
arr[getR(path)]++;
}
//6.输出
System.out.println(Arrays.toString(arr));
show(arr);
}
public static void show(int[] arr){
int w=arr.length;
int h=0;
for(int i=0;i<arr.length;i++){
if(arr[i]>h){
h=arr[i];
}
}
for(int i=h-1;i>=0;i--){
for(int j=0;j<w;j++){
if(i<arr[j]){
System.out.print("O");
}else{
System.out.print(" ");
}
}
System.out.println();
}
}
public static int getR(String path){
int count=0;
for(int i=0;i<path.length();i++){
if(path.charAt(i)=='R'){
count++;
}
}
return count;
}
public static String getPath(int slots){
//4.根据槽子的个数计算每一个球下落的路径
Random random=new Random();
String path="";
for(int j=0;j<slots-1;j++){
if(random.nextInt(2)==0){ //向左
path+="L";
}else{ //向右
path+="R";
}
}
return path;
}
}4、
import java.util.*;
class Home5_1{
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
int[] arr=new int[0];
System.out.print("Enter numbers:");
while(true){
int num=scanner.nextInt();
if(num==0){
break;
}
//验证用户输入数据的正确性
if(num<1||num>100){
System.out.println("有非法数据！");
return;
}
arr=copyOf(arr,arr.length+1);
arr[arr.length-1]=num;
}
//2.按照输出结果 将数据中的数据进行排序
insertSort(arr);
//3.输出连续相等的数字
show(arr);
}
public static int[] copyOf(int[] arr,int newLen){
int[] newArr=new int[newLen];
for(int i=0;i<arr.length;i++){
newArr[i]=arr[i];
}
return newArr;
}
public static void insertSort(int[] arr){
for(int i=1;i<arr.length;i++){
int e=arr[i];
int j;
for(j=i;j>0&&arr[j-1]>e;j--){
arr[j]=arr[j-1];
}
arr[j]=e;
}
}
/*
Arrays Math都是属于工具类
Arrays 特殊的是数组的工具类
toString(arr) 就是将数据的每个元素进行拼接 并返回拼接后的字符串数据
*/
public static void show(int[] arr){
System.out.println(Arrays.toString(arr));
//[1, 1, 1, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 5, 5, 6]
for(int i=0;i<arr.length;){
int count=1;
for(int j=i+1;j<arr.length;j++){
if(arr[j]==arr[i]){
count++;
}else{
break;
}
}
System.out.println(arr[i]+" occurs "+count+(count>1?" times":" time"));
i+=count;
}
}
}5、
class Home5_5{
public static void main(String[] args){
int[] list1={1,3,2,5,4,7,6};
int[] list2={1,2,3,4,5,7,6};
System.out.println(equals(list1,list2));
}
public static boolean equals(int[] list1,int[] list2){
//判断两个数组是否完全相同
//1.先判断长度
if(list1.length!=list2.length){
return false;
}
//2.再依次判断元素大小
for(int i=0;i<list1.length;i++){
if(list1[i]!=list2[i]){
return false;
}
}
return true;
}
}6、
class Demo05_06{
public static void main(String[] args){
int[] arr={1,1,1,1,2,2,2,2,2,3,3,3,3,3,4};
for(int i=0;i<arr.length;){
int count=1;
for(int j=i+1;j<arr.length;j++){
if(arr[i]==arr[j]){
count++;
}else{
break;
}
}
if(count>=4){
System.out.println(arr[i]);
return;
}
i+=count;
}
System.out.println("没有！");
}
}7、
import java.util.*;
class Demo05_07{
public static void main(String[] args){
int[] list1={1,3,5,7,9};
int[] list2={2,4,6,8,10};
System.out.println(Arrays.toString(merge(list1,list2)));
}
/*
有序数组的合并，最主要的问题在于 数组之间有长有短
*/
public static int[] merge(int[] list1,int[] list2){
if(list1==null&&list2==null){
return null;
}
if(list1==null){
return list2;
}
if(list2==null){
return list1;
}
//只有两个都不是null的情况再考虑具体操作
int[] list3=new int[list1.length+list2.length];
int p1=0;
int p2=0;
int p3=0;
while(true){
if(p1==list1.length&&p2==list2.length){
break;
}
if(p1<list1.length&&p2==list2.length){
list3[p3++]=list1[p1++];
}else if(p1==list1.length&&p2<list2.length){
list3[p3++]=list2[p2++];
}else{
if(list1[p1]<=list2[p2]){
list3[p3++]=list1[p1++];
}else{
list3[p3++]=list2[p2++];
}
}
}
return list3;
}
}8
import java.util.*;
class Demo05_08{
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
Random random=new Random();
//1.创建一个单词表
String[] words={"naruto","kakashi","sasuke","banana","java","program"};
//10.最后再去做多单词猜测
while(true){
//2.随机从单词表中抽取一个单词
String word=words[random.nextInt(words.length)];
//3.创建一个该单词的状态表 默认值是false
boolean[] status=new boolean[word.length()];
int miss=0; //猜错的个数
//4.开始猜一个单词
while(true){
//5.根据单词和状态表 决定密文形式
String ciphertext=getCipherText(word,status);
//6.输出密文并提示用户输入字母
System.out.print("Enter a letter in word "+ciphertext+" >");
char letter=scanner.nextLine().charAt(0);//"p".charAt(0)
//7.判断单词中是否有该字母
if(isContainsLetter(word,letter)){
if(!changeWordStatus(word,status,letter)){
System.out.println("\t "+letter+" is already in the word");
}
}else{
System.out.println("\t "+letter+" is not in the word");
miss++;
}
//7.是否结束
if(isFinish(status)){
System.out.println("The word is "+word+". You miss "+miss+" time");
break;
}
}
System.out.print("Do you want to guess another word?Enter y or n:");
String choice=scanner.nextLine();
if(choice.equals("n")){
System.out.println("Welcome!Thank you! FUCK PROGRAM!");
break;
}
}
}
public static boolean isFinish(boolean[] status){
for(int i=0;i<status.length;i++){
if(!status[i]){
return false;
}
}
return true;
}
public static boolean changeWordStatus(String word,boolean[] status,char letter){
for(int i=0;i<word.length();i++){
if(word.charAt(i)==letter){
if(status[i]){
return false; //说明已经修改
}else{
status[i]=true;
}
}
}
return true;
}
public static boolean isContainsLetter(String word,char letter){
for(int i=0;i<word.length();i++){
if(word.charAt(i)==letter){
return true;
}
}
return false;
}
public static String getCipherText(String word,boolean[] status){
String ciphertext="";
for(int i=0;i<status.length;i++){
if(status[i]){
ciphertext+=word.charAt(i);
}else{
ciphertext+="*";
}
}
return ciphertext;
}
}
108
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
