一、一维数组
含义
一组数据的容器，内存中的一段连续空间
概念
1.数组都是引用数据类型
2.数组中的数据叫做元素
3.每个元素都有编号，叫做下标/索引
4.小标从0开始
为什么用数组？
便于对多个相同类型的变量统一管理
特点
1.类型相同（相对的）
2.长度固定
数组的声明
数据类型[ ] 数组名;数组的使用
声明 分配空间 赋值 使用
数组越界
ArrayIndexOutBoundException
索引>=length||索引<0
1.数组的初始化
静态初始化
初始化时，由程序员指定数据，由系统分配空间
public static void main(String[] args){
//静态初始化1
//String[] names = new String[]{"麻生希","椎名空","水菜丽","朝桐光","樱井步"};
//静态初始化2(先声明，再初始化)
//String[] names;
//names = new String[]{"麻生希","椎名空","水菜丽","朝桐光","樱井步"};
//静态初始化3
String[] names = {"麻生希","椎名空","水菜丽","朝桐光","樱井步"};
//通过下标设置元素 -- 修改
names[1] = "钟长江";
//ArrayIndexOutOfBoundsException - 数组下标越界异常
//names[5] = "李博";
//通过下标获取元素 -- 查询
String n = names[1];
System.out.println("通过下标获取元素：" + n);
//获取元素个数 -- 查询
int len = names.length;
System.out.println("获取元素个数：" + len);//5
System.out.println("----------------");
//遍历数组 -- for循环
for(int i = 0;i<names.length;i++){
System.out.println(names[i]);
}
System.out.println("----------------");
//遍历数组 -- 增强for循环/foreach
//含义：依次遍历数组中的元素，并把元素赋值给element遍历
for(String element : names){
System.out.println(element);
}
System.out.println("----------------");
/**
for vs foreach
遍历时需要下标，就使用for循环
遍历是不需要下标，就使用foreach
*/
//需求：将names中所有的元素都设置成"卢忠辉",并输出
for(int i = 0;i<names.length;i++){
names[i] = "卢忠辉";
}
for(String element : names){
System.out.println(element);
}
}
}动态初始化
数组是有默认值的，初始化时由程序员指定空间，由系统分配默认值
系统分配默认值类型
整数类型：0 浮点类型：0.0 char类型：'\u0000 ' (相当于一个空格) String类型：null
布尔类型：false 引用数据类型：null(空)
public static void main(String[] args){
//动态初始化1
//String[] names = new String[5];//5表示开辟5个连续的空间
//动态初始化2(先声明，再初始化)
String[] names;
names[0] = "关谷神奇";
names[1] = "明日花绮罗";
names[2] = "桃谷绘里香";
names[3] = "铃原爱蜜莉";
names[4] = "小西满里惠";
//ArrayIndexOutOfBoundsException -- 数组下标越界异常
//names[5] = "钟长江";
//通过下标获取元素 -- 查询
String n = names[1];
System.out.println("通过下标获取元素：" + n);
//获取元素个数 -- 查询
int len = names.length;
System.out.println("获取元素个数：" + len);//5
System.out.println("----------------");
//遍历数组 -- for循环
for(int i = 0;i<names.length;i++){
System.out.println(names[i]);
}
System.out.println("----------------");
//遍历数组 -- 增强for循环/foreach
//含义：依次遍历数组中的元素，并把元素赋值给element遍历
for(String element : names){
System.out.println(element);
}
System.out.println("----------------");
/**
for vs foreach
遍历时需要下标，就使用for循环
遍历是不需要下标，就使用foreach
*/
//需求：将names中所有的元素都设置成"卢忠辉",并输出
for(int i = 0;i<names.length;i++){
names[i] = "卢忠辉";
}
for(String element : names){
System.out.println(element);
}
}
}静态初始化 vs 动态初始化
初始化时知道具体数据，就使用静态初始化
初始化时只知道长度，就使用动态初始化
注意事项
1.变量是存储单个数据的容器，而数组是存储多个数据的容器
2.一维数组开辟的空间是连续的.（好处：查询效率快）
3.数组一旦初始化成功，长度不可改变 （意味着数组不能添加、删除）
4.操作数组只能查询和修改数组
5.new表示新建对象
需求
创建5个int值长度的数组，5个值由用户输入，求出最大值
import java.util.Scanner;
public class Test03{
/**
知识点：一维数组
需求：创建5个int值长度的数组，5个值由用户输入，求出最大值
*/
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
//创建5个int值长度的数组
int[] is = new int[5];
//5个值由用户输入
for(int i = 0;i<is.length;i++){
System.out.println("请输入第" + (i+1) + "个数字：");
int num = scan.nextInt();
is[i] = num;
}
//求出最大值
int max = is[0];//默认数组的第一个元素是最大值
for(int i = 1;i<is.length;i++){
if(max < is[i]){
max = is[i];
}
}
System.out.println("最大值为：" + max);
}
}2.数组的排序
为什么数组要排序？
数据的应用？--如果数据没有顺序，要查找只能顺序查找
我们以后数据的增删改，在实际项目中占比不到10%，绝大部分时间是进行数据查询
为了优化查询效率，就需要排序
排序算法
冒泡排序 （时间复杂度O(n*n)） 选择排序（时间复杂度O(n*n) 插入排序 （时间复杂度O(n*n)）
快速排序(是对冒泡排序的改良) （时间复杂度 O( nlogn ) ）
堆排序(是对选择排序的改良) （时间复杂度 O( nlogn ) ）
希尔排序(是对插入排序的改良) （时间复杂度 O( nlogn ) ）
归并排序 （时间复杂度 O( nlogn ) ）
桶排序 计数排序 基数排序 （时间复杂度 O(n) ）
冒泡排序
public class Test04{
/**
知识点：数组的排序--冒泡排序
口诀：
N个数字来排序
两两相比小靠前
外层循环N-1
内层循环N-1-i
*/
public static void main(String[] args){
int[] is = {52,18,49,95,36,2,45};
for(int i =0;i<is.length-1;i++){
for(int j =0;j<is.length-1-i;j++){
if(is[j]>is[j+1]){
int temp = is[j];
is[j] = is[j+1];
is[j+1] = temp;
}
}
}
for(int element :is){
System.out.println(element);
}
}
}3.数组的查找
线性查找
int[] is = {69,72,81,54,19,10};
int num = 81;
for(int i =0;i<is.length;i++){
if(is[i] == num){
System.out.println("查找到了，下标为：" + i);
break;
}
}二分查找法
含义
把数组分成左右两边，分别去查找
注意
二分法查找前必须排序
import java.util.Arrays;
public class Test05{
public static void main(String[] args){
int[] is = {69,72,81,54,19,10};
//排序 -- 10,19,54,69,72,81
Arrays.sort(is);
int num = 81;
int start = 0;
int end = is.length-1;
while(start <= end){
int mid = (start + end)/2;
if(num > is[mid]){
start = mid+1;
}else if(num< is[mid]){
end = mid-1;
}else{
System.out.println("查找到了，下标为：" + mid);
break;
}
}
}
}4.数组的复制
4.1浅表复制
缺点
修改原数组后，新数组的数据也会发生改变
public class Test06{
public static void main(String[] args){
//原数组
String[] names ={"水野朝阳","爱田奈奈","古川伊织","北条麻衣"};
//新数组
String[] newNames =names;
//改变原数组中的数据
names[1] = "王与";
//遍历新数组
for(String element : newNames){
System.out.println(element);
}
}
}4.2复制方法2
public class Test06{
public static void main(String[] args){
//原数组
String[] names ={"水野朝阳","爱田奈奈","古川伊织","北条麻衣"};
//新数组
String[] newNames =new String[names.length];
//循环遍历原数组，将原数组中的元素依次赋值给新数组
for(int i =0;i<name.length;i++ ){
newNames[i] = names[i];
}
//改变原数组中的数据
names[1] = "王与";
//遍历新数组
for(String element : newNames){
System.out.println(element);
}
}
}5.数组的扩容
public class Test08{
public static void main(String[] args){
//原数组
String[] names ={"水野朝阳","爱田奈奈","古川伊织","北条麻衣"};
//新数组
int oldCapacity = names.length;
int newCapacity = oldCapacity + (oldCapacity >>1); //新数组的长度是原数组的1.5倍
String[] newNames = new String[newCapacity];//[null;null;null;null;null;null;]
//循环遍历原数组，将原数组中的元素依次赋值给新数组
//newNames-- ["水野朝阳","爱田奈奈","古川伊织","北条麻衣";null;null]
for(int i =0;i<names.length;i++ ){
newNames[i] = names[i];
}
//将新数组的内存地址赋值给原数组
names = newNames;
//遍历新数组
for(String element : names){
System.out.println(element);
}
}
}package com.wy.week2.day07.array;
import java.util.Arrays;
public class ArrayExtends {
public static void main(String[] args) {
int[] nums = { 1, 2, 3 };
nums = Arrays.copyOf(nums, nums.length - 1);//数组长度减
// nums = grow(nums);
// nums[3] = 4;
System.out.println(Arrays.toString(nums));
}
/**
* 写一个数组扩容的方法，每次长度+1
*/
public static int[] grow(int[] nums) {
int[] newNums = new int[nums.length + 1];//长度+1
for (int i = 0; i < nums.length; i++) {
newNums[i] = nums[i];
}
return newNums;// 赋值
}
/*
* int[] nums={1,2,3,4};
*
* nums=extendsArray(nums); System.out.println(Arrays.toString(nums));
* nums=extendsArray(nums); System.out.println(Arrays.toString(nums)); }
* //函数扩容方法 每次长度+1 private static int[] extendsArray(int[] nums) { int[]
* newNums=new int[nums.length+1]; for(int i=0;i<nums.length;i++){
* newNums[i]=nums[i]; } return newNums;//赋值
*
* }
*/
}6.数组的删除1
/*
知识点：数组的删除1
缺点：数组是用来存储数据的，以这个方式删除，会把空间越变越小
*/
public class Test09{
public static void main(String[] args){
//原数组
String[] names ={"水野朝阳","爱田奈奈","古川伊织","北条麻衣"};
//新数组
String[] newNames = new String[names.length-1]; //[null,null,null]
//循环遍历原数组，将原数组中的元素(除了要删除的元素外)依次赋值给新数组
//newNames-- [null;null;null]
int index = 0; //新数组的下标
for(String element : names ){
if(!element.equals("爱田奈奈")){
newNames[index++] = element;
}
}
//将新数组的内存地址赋值给原数组
names = newNames;
//遍历原数组
for(String element : names){
System.out.println(element);
}
}
}7.数组的删除2
public class Test10{
public static void main(String[] args){
//原数组
String[] names ={"水野朝阳","爱田奈奈","古川伊织","北条麻衣"};
//将要删除的元素给覆盖掉
for(int i =1;i<names.length-1;i++){
names[i] = names[i+1];
}
//将最后元素的为值赋值为null
names[names.length-1] = null;
//遍历原数组
for(String element : names){
System.out.println(element);
}
}
}8.数组作为方法的参数与返回值
需求
设计一个方法，传入int数组，返回最大值和最小值
public static void main(String[] args){
int[] is = {69,72,81,54,19,8};
int[] maxAndMin = getMaxAndMin(is);
System.out.println("最大值为：" + maxAndMin[0]);
System.out.println("最小值为：" + maxAndMin[1]);
}
public static int[] getMaxAndMin(int[] is){
//假设下标为0位置上的元素既是最大值又是最小值
int max = is[0];
int min = is[0];
for(int i = 1;i<is.length;i++){
if(max < is[i]){
max = is[i];
}
if(min > is[i]){
min = is[i];
}
}
return new int[]{max,min};
}
}注意
1.方法的参数可以有多个
2.方法的返回值只能有一个（如果想返回多个数据，就可以把多个数据放在一个数组里）
9.可变参数
语法
数据类型... 变量名
//需求：设计一个方法，传入8个int值，比较最大值
public static void main(String[] args){
//注意2：传入实参，底层会把实参看作为数组的元素
int max = getMax(1,2,3,4,5);
System.out.println("最大值为：" + max);
}
//注意1：可变参数本质就是数组
public static int getMax(int... is){
if(is.length > 0){
int max = is[0];
for(int i = 1;i<is.length;i++){
if(max < is[i]){
max = is[i];
}
}
return max;
}
return 0;
}
//注意3：可变参数后面不能加其他参数
public static void method(int i,String... ss){
}
}10.Arrays工具类
含义
Java给我们提供的专门操作数组的类
工具类的概念
该类里的方法都是静态的，直接使用类名调用即可
API：Java类的使用说明书
public static void main(String[] args){
int[] is = {69,72,81,54,19,8};
//排序 -- [8,19,54,69,72,81]
Arrays.sort(is);
//查找
//返回值 -- 如果查询的值在数组中就返回下标，如果不在就返回-插入点-1
int index = Arrays.binarySearch(is,20);
System.out.println("查找元素的下标为：" + index);
//拷贝
int[] copyOf = Arrays.copyOf(is,is.length);//(目标数组，要拷贝的长度)
//局部拷贝
int[] copyOfRange = Arrays.copyOfRange(copyOf,1,4);//(目标数组，开始下标-包含，结束下标-不包含)
//替换
Arrays.fill(copyOfRange,888);
//将数组转化为字符串 -- [8,19,54,69,72,81]
String str = Arrays.toString(copyOfRange);
System.out.println(str);
}
}典型题
package com.wy.week2.day07.work;
import java.util.Arrays;
public class Bubbling {
public static void main(String[] args) {
//5.利用冒泡排序对数据进行降序排序
int [] nums={1,3,6,7,8,9,45,23,12};
//外层循环控制轮数，内存循环控制每轮的次数
for(int i=0;i<nums.length-1;i++){
for(int j=0;j<nums.length-1;j++){
//比较相邻数的大小，并进行降序排序
if(nums[j]<nums[j+1]){
int temp=nums[j];
nums[j]=nums[j+1];
nums[j+1]=temp;
}
}
}
System.out.println(Arrays.toString(nums));
}
}
package com.wy.week2.day07.work;
import java.util.Arrays;
public class CountingSort {
public static void main(String[] args) {
// 计数排序完成1亿个年龄（1-100）的排序，统计时间
int[] nums=new int[1000];
for(int i=0;i<nums.length;i++){
nums[i]=(int)(Math.random()*100+1);//随机录入1-100的数
}
System.out.println(Arrays.toString(nums));
long t0=System.currentTimeMillis();//用来获取当前的总毫秒数
//统计
int[] counts=new int[100];//用一个长度100的数组来存每个年龄出现的次数
for(int i=0;i<nums.length;i++){
counts[nums[i]-1]++; //记录每个年龄出现的次数
}
System.out.println(Arrays.toString(counts));
//还原数组
int[] newNums=new int[nums.length];
int index = 0;
for(int i=0;i<counts.length;i++){
for(int j=0;j<counts[i];j++){
newNums[index++] = i+1;
}
}
nums=newNums;
System.out.println(Arrays.toString(nums));
long t1=System.currentTimeMillis();//用来获取当前的总毫秒数
System.out.println((t1-t0)+"ms");
}
}
package com.wy.week2.day07.work;
import java.util.Arrays;
public class Flip {
public static void main(String[] args) {
/*
* 8.提取一个方法，将指定数组中的数组元素进行反转
例如：{10,23,2,45,6}--->{6,45,2,23,10}
*/
int[] nums={10,23,2,9,8,45,6};
flip(nums);
}
//反转数组的方法
public static void flip(int[] nums) {
//int[] newNums=new int[nums.length];
//将数组内容反转
for(int i=0;i<nums.length/2;i++){
int temp=nums[i];
nums[i]=nums[nums.length-i-1];
nums[nums.length-i-1]=temp;
}
System.out.println(Arrays.toString(nums));
/*for(int i=0;i<nums.length;i++){
newNums[i]=nums[i];
}
System.out.println(Arrays.toString(newNums));*/
}
}package com.wy.week2.day07.work;
import java.util.Arrays;
public class Merge {
public static void main(String[] args) {
int[] nums1 = {1,2,3,4,5,7,9,12,24};
int[] nums2 = {3,4,6,8,9,100};
int[] newNums=new int[nums1.length+nums2.length];
int n=-1;
int m=-1;
for (int i = 0; i <nums1.length+nums2.length ; i++) {
n++;
if (i<nums1.length){
newNums[n]=nums1[i];
}else {
m++;
newNums[n]=nums2[m];
}
}
for(int i=0;i<newNums.length-1;i++){
for(int j=0;j<newNums.length-1;j++){
//比较相邻数的大小，并进行降序排序
if(newNums[j]>newNums[j+1]){
int temp=newNums[j];
newNums[j]=newNums[j+1];
newNums[j+1]=temp;
}
}
}
System.out.println(Arrays.toString(newNums));
//int[] nums = method(nums1,nums2);
//System.out.println(Arrays.toString(nums));
}
/*public static int[] method(int[] nums1, int[] nums2) {
int[] num = new int[nums1.length+nums2.length];
int i=0,j=0;
while(i<nums1.length && j<nums2.length) {
if(nums1[i]<nums2[j]) {
num[i+j] = nums1[i];
i++;
}else {
num[i+j] = nums2[j];
j++;
}
}
if(i==nums1.length) {
for(;j<nums2.length;j++) {
num[i+j] = nums2[j];
}
}
if(j==nums2.length-1){
for(;i<nums1.length;i++) {
num[i+j] = nums1[i];
}
}
return num;
} */
}
7万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
