数组
指的是一组数据( 批量)
数组在内存中是若干个大小一致，类型一样，地址连续的存储空间
提供角标访问元素 如果数组大小为10(10个元素) 角标：0~9
在数组中，查找元素的时间复杂度O(1) 只要计算一次，即可得到元素吗，与元素的个数无关
存储
变量-局部变量(在函数中创建的变量) 内存中 栈内存中 函数的所属空间里
数组在堆内存中存储
Java中内存大致分布情况
-
寄存器：存储CPU计算的一些临时数据
-
本地方法区：存储操作系统执行的部分代码
-
方法区：存储应用软件执行的部分代码
-
栈内存：存储所运行函数的代码
-
堆内存：存储对象的！
基本数据类型->常量->常量池->方法区
引用数据类型->对象->堆内存
但凡是在堆内存中的数据 都有默认初始化值!!
创建
class Demo01{
public static void main(String[] args){
int [ ] arr=new int[5];
- new:创建一个数组
- int [5]:整形且长度为5
- 然后将这个对象的地址给变量arr
- int[ ]:数据类型
- [ ]：表示一维数组
- [ ][ ]:二维数组
创建流程
- 函数中定义变量空间并起名
- 在堆内存中根据长度创建数组
- 对每一个元素进行默认初始化 int->0 double->0.0 boolean->false
- 将数组中第一个元素的地址当成整个数组的地址传递给变量
- 变量指向该数组(引用数据类型)
定义数组
1数据类型[] 数组名=new 数据类型[长度];
2数据类型[] 数组名=new 数据类型[]{元素1,元素2,…};
3数据类型[] 数组名={元素1,元素2,…};
数组的遍历
class Demo01{
public static void main(String[] args) {
bianli();
}
public static void bianli(){ //输出 1 2 3 4 5 6
//int[] arr=new int[]{1,2,3,4,5,6};
int[] arr={1,2,3,4,5,6}; //建立数组arr
for(int i=0;i<arr.length;i++){ // i从0-5.arr,length表示长度
System.out.print(arr[i]+" ");
}
System.out.println(); //输出6 5 4 3 2 1
for(int i=arr.length-1;i>=0;i--){ //i从5-0；
System.out.print(arr[i]+" ");
}
System.out.println();
}
}
数组的查找
- 线性查找
class Demo01{
public static void main(String[] args) {
find();
} 3 2 1 9 5 6 8 7
public static void find(){ 坐标 ： 0 1 2 3 4 5 6 7
int[] arr={3,2,1,9,5,6,8,7}; 输入一个key值，从左到右依次比较
int key=8;//找元素key的角标 有相等的输出他的坐标
int index=-1; 没有相等的输出index的初始值 -1
for(int i=0;i<arr.length;i++){
if(arr[i]==key){
index=i;
break;
}
}
System.out.println(index);
}
- 二分查找
class Demo01{
public static void main(String[] args) {
find();
} 1 2 3 4 5 6 7 8 9
public static void find(){ 坐标： 0 1 2 3 4 5 6 7 8
arr=new int[]{1,2,3,4,5,6,7,8,9}; 输入一个key值，low(mindlndex) high(maxindex)
key=6; 初始条件下low=0,high=arr,length-1.
int minIndex=0; 让mid表示中间元素的下标，这样mid=（low+high)/2.
int maxIndex=arr.length-1; 如果key<arr[mid]，就将high的下标设置为mid-1，
int midIndex=(minIndex+maxIndex)/2; 如果key==arr[mid],则匹配成功返回mid;
index=-1; 如果key>arr[mid]，就将low下标设置为mid+1
while(true){
if(arr[midIndex]>key){
maxIndex=midIndex-1;
}else if(arr[midIndex]<key){
minIndex=midIndex+1;
}else{
index=midIndex;
break;
}
midIndex=(minIndex+maxIndex)/2;
if(minIndex>maxIndex){
break;
}
}
System.out.println(index);
}
数组的扩容
class Demo01{
public static void main(String[] args) {
resize();
}
public static void resize(){
int[] arr=new int[]{1,2,3,4,5};
int deltSize=-2;//-缩 +扩
int[] newArr=new int[arr.length+deltSize];
//将原先的数据放入到新数组中
for(int i=0;i<Math.min(arr.length,newArr.length);i++){
newArr[i]=arr[i];
}
arr=newArr;//偷梁换柱 狸猫换太子 暗度陈仓
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
System.out.println();
}
数组的排序
class Demo01{
public static void main(String[] args) {
//4.1 选择O(n^2)
selectedSort();
//4.2 冒泡O(n^2)
bubbleSort();
//4.3 插入(希尔)O(n^2) 更好
insertSort();
}
// 插入(希尔)O(n^2) i
public static void insertSort(){ 5 1 3 2 7 4 9 8 6
int[] arr={5,1,3,2,7,4,9,8,6}; j j+1
for(int i=1;i<arr.length;i++){ 1 5 3 2 7 4 9 8 6
int e=arr[i];
int j=i-1;
while(j>=0&&arr[j]>e){
arr[j+1]=arr[j];
j--;
}
arr[j+1]=e;
}
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
System.out.println();
}
class Demo04{
public static void main(String[] args) {
插入（已知的数字）
int[] ins=new int[]{1,1,2,3,4,5,6,5,1,2,3};
int[] ins2=sort(ins);
for(int in:ins2){
System.out.print(in);
}
}
public static int[] sort(int[] ins){
for(int i=1;i<ins.length;i++){
for(int j=i;j>0;j--){
if(ins[j]<ins[j-1]){
int temp=ins[j-1];
ins[j-1]=ins[j];
ins[j]=temp;
}
}
}
return ins;
}
}
// 冒泡O(n^2)排序 5 1 3 2 7 4 9 8 6
public static void bubbleSort(){ j j+1
int[] arr={5,1,3,2,7,4,9,8,6}; 1 5 3 2 7 4 9 8 6
//i仅仅表示轮数 1 3 5 2 7 4 9 8 6
for(int i=0;i<arr.length-1;i++){ 1 3 2 5 7 4 9 8 6
for(int j=0;j<arr.length-i-1;j++){ 1 3 2 5 7 4 9 8 6
if(arr[j]>arr[j+1]){ 1 3 2 5 4 7 9 8 6
int temp=arr[j]; 1 3 2 5 4 7 9 8 6
arr[j]=arr[j+1]; 1 3 2 5 4 7 8 9 6
arr[j+1]=temp; 1 3 2 5 4 7 8 6 9
}
}
}
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
System.out.println();
}
//选择O(n^2) 排序 //从第一位开始，和每一位数字进行比较，知道最后一位
public static void selectedSort(){
int[] arr={5,1,3,2,7,4,9,8,6};
for(int i=0;i<arr.length-1;i++){
for(int j=i+1;j<arr.length;j++){
if(arr[i]>arr[j]){
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
}
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
System.out.println();
}
提示
- 单个的数组变量可以引用一个大的数据集合。
- 一旦数组被创建，他的大小是固定的。使用一个数组引用变量，通过下标来访问数组中的元素。
- 数组引用变量[下标]; myList[9]表示数组myList的最后一个元素。
- 对于char 类型的数组可以使用一条打印语句打印。
char [ ] city={'d','a','1','s');
System.out.println(city);
数组的特点：长度一旦确定，不可改变
创建一个指定长度的数组，但是元素是默认值
警告
double [ ] myList={1.9,2.9,3.9,4.9}
等于
double [ ] myList=new double[4];
myList[0]=1.9;
myList[0]=2.9;
myList[0]=3.9;
myList[0]=4.9;
数组初始化语法中不使用操作符new。使用数组初始化语法时，必修严明、创建和初始化数组都在一条语句中。将他们分开会产生语法错误。
题型
1编写程序，读取1到100之间的整数，然后计算每个数字出现的次数，假定输入是以0结束的。
import java.util.Scanner;
/*1创建俩个长度为0的数组，一个存储数字，一个存储数字出现的次数
2对输入数字进行判断，如果输入的数字为0，直接结束循环，如果不是则正在进行判断
3判断输入的数字是否已经出现过，如果出现了则找到相应的下标进行加1，如果没有出现则使数组扩容加1
4进行插入排序，并按出现的次数输出。
class Demo01{
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
int[] nums=new int[0]; //存储数字
int[] counts=new int[0];//存储次数
System.out.print("请输入数字：");
while(true){
int number=scanner.nextInt();
if(number==0){
break;
}
int index=indexOf(nums,number);
if(index!=-1){
counts[index]++;
}else{
nums=addNum(nums,number);
counts=addCount(counts);
}
}
sort(nums, counts);
for(int i=0;i<nums.length;i++){
System.out.println(nums[i]+"occurs"+counts[i]+(counts[i]>1?"times":"time"));
}
}
public static void sort(int[] nums,int[] counts){
for(int i=1;i<nums.length;i++){
int e=nums[i];
int f=counts[i];
int j=i-1;
while(j>=0&&nums[j]>e){
nums[j+1]=nums[j];
counts[j+1]=counts[j];
j--;
}
nums[j+1]=e;
counts[j+1]=f;
}
}
public static int[] addNum(int[] nums,int number){
int arr[]=new int[nums.length+1];
for(int i=0;i<nums.length;i++){
arr[i]=nums[i];
}
arr[arr.length-1]=number;
return arr;
}
public static int[] addCount(int[] counts){
int[] arr=new int[counts.length+1];
for(int i=0;i<counts.length;i++){
arr[i]=counts[i];
}
arr[arr.length-1]=1;
return arr;
}
public static int indexOf(int[] nums,int number){
for(int i=0;i<nums.length;i++){
if(nums[i]==number){
return i;
}
}
return -1;
}
}
思路
1创建一个长度为0的数组，输入数字，如果为0直接退出循环
2不为0，进行扩容输入。然后排序
3count出现次数开始默认为1，每次和他的下一位进行比较，如果相同count+1，如果不同直接输出
4输出后i的位置移到了i+count
import java.util.Scanner;
class Class29_2{
public static void main(String[] args){
//4 3 2 5 4 2 8 3 2 1 2 3 4
//1 2 2 2 2 3 3 3 4 4 4 5 8
//连续匹配
Scanner scanner=new Scanner(System.in);
int[] arr=new int[0];
System.out.println("请输入数字：");
while(true){
int num=scanner.nextInt();
if(num==0){
break;
}
arr=addNumber(arr,num);
}
sort(arr);
//1 2 2 2 2 3 3 3 4 4 4 5 8
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;
}
}
System.out.println(arr[i]+" occurs "+count+(count>1?" times":" time"));
i=i+count;
}
}
public static void sort(int[] arr){
for(int i=0;i<arr.length-1;i++){
for(int j=i+1;j<arr.length;j++){
if(arr[i]>arr[j]){
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
}
}
public static int[] addNumber(int[] arr,int num){
int[] newArr=new int[arr.length+1];
for(int i=0;i<arr.length;i++){
newArr[i]=arr[i];
}
newArr[newArr.length-1]=num;
return newArr;
}
}
1直接将输入的数字和下表一一对应
2每次出现arr[i]++;
3输出
import java.util.Scanner; 4 5 6 5 4 8 2 3 4 5
class Class29_3{ 输入数字 2 3 4 5 6 8
public static void main(String[] args){ 下标 0 1 2 3 4 5 6 7 8 9 10
int[] arr=new int[101]; 次数 1 1 3 3 1 1
//index:0 1 2 3 4 5 6 7 8 9 10
Scanner scanner=new Scanner(System.in);
System.out.print("请输入数字：");
while(true){
int num=scanner.nextInt();
if(num==0){
break;
}
arr[num]++;
}
for(int i=1;i<arr.length;i++){
if(arr[i]>0){
System.out.println(i+" occurs "+arr[i]+(arr[i]>1?" times":" time"));
}
}
}
}
2编写一个程序，读取10个整数，消除数组中重复出现的值，然后显示结果
1首先创建一个长度为0的数组
2在输入数字的同时进行判断（isNumberlnArray)
3输入的数字在不在数组中，没有的话扩容，输出
import java.util.Scanner;
class Class30{
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
System.out.print("Enter ten number:");
int[] arr=new int[0];//扩容
for(int i=0;i<10;i++){
int number=scanner.nextInt();
if(!isNumberInArray(arr,number)){ //！isNumberlnArray 是如果相同的数字不管，不相同的回返回false，形成(！false)=true继续执行
arr=add(arr,number);
}
}
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
}
public static int[] add(int[] arr,int number){
int[] newArr=new int[arr.length+1];
for(int i=0;i<arr.length;i++){
newArr[i]=arr[i];
}
newArr[newArr.length-1]=number;
return newArr;
}
public static boolean isNumberInArray(int[] arr,int number){
for(int i=0;i<arr.length;i++){
if(arr[i]==number){
return true;
}
}
return false;
}
}
思路
1建立一个数组长度为10的数组，同时有效长度为0
2输入数字时先进行判断他是否已经存在，如果不存在将他放在指定的该有效位置上，并且有效位加1
3最后输出有效位的数字
import java.util.Scanner;
class Class30_2{ 输入 1 5 3 2 1 4 2 1 4 1
public static void main(String[] args){
Scanner scanner=new Scanner(System.in); 0 0 0 0 0 0 0 0 0 0
System.out.print("Enter ten number:"); 1 5 3 2 4
int[] arr=new int[10]; //有效个数
int size=0;
for(int i=0;i<10;i++){
int number=scanner.nextInt();
if(!isNumberInArray(arr,number,size)){
arr[size]=number;
size++;
}
}
for(int i=0;i<size;i++){
System.out.print(arr[i]+" ");
}
}
public static boolean isNumberInArray(int[] arr,int number,int size){
for(int i=0;i<size;i++){
if(arr[i]==number){
return true;
}
}
return false;
}
}
思路
1创建一个长度为10的数组
2将10个整数依次输入进去
3排序
4从最后一位开始判断，他的前一位如果与他相等，从他开始向前移动一位对其进行覆盖，随后有效位减1
5最后只输出有效位
import java.util.Scanner;
class Class30_3{
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
System.out.print("Enter ten number:");
int[] arr=new int[10]; //有效个数
for(int i=0;i<arr.length;i++){
arr[i]=scanner.nextInt();
}
//1 2 3 2 1 6 3 4 5 2
//再进行消除重复
sort(arr);
//1 1 2 2 2 3 3 4 5 6
int size=arr.length;
for(int i=arr.length-1;i>0;i--){
if(arr[i]==arr[i-1]){
for(int j=i;j<size;j++){ 1 2 5 4 6 5 4 2 6 6
arr[j-1]=arr[j]; 排序1 2 2 4 4 5 5 6 6 6
} 1 2 2 4 4 5 5 6
size--; 1 2 2 4 4 5 6
} 1 2 2 4 5 6
} 1 2 4 5 6
for(int i=0;i<size;i++){
System.out.print(arr[i]+" ");
}
}
public static void sort(int[] arr){
for(int i=0;i<arr.length-1;i++){
for(int j=i+1;j<arr.length;j++){
if(arr[i]>arr[j]){
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
}
}
}
扫一扫
343
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
