数组概念
数组是先声明，在开辟空间的，但是开辟完空间后长度是固定的
所以数组一旦创建完成之后，它的长度就不变了
数组没有赋值，但是会有个默认值
* int 类型默认值是 0
* double 是 0.00
* boolean 是false
* String 是 null
public class Demo01 {
public static void main(String[] args) {
/**
* 数组，是先声明，在开辟空间的，但是开辟完空间后，长度就固定了
* 所以数组一旦创建完成之后，它的长度就不变了
* 数组没有赋值，但是会有个默认值
* int 类型默认值是 0
* double 是 0.00
* boolean 是false
* String 是 null
*/
/**
* 1、实例：随机在1-1000里面抽取一位数，能够被3整除就可以保存，知道存储10位就停止
* 2、可以实现每次插入数据后，数组都是从大到小排序的吗？
*/
Random random = new Random();
int[] nums = new int[10];
int i = 0;
while (true) {
int num = random.nextInt(1000);
if(num%3 == 0){
nums[i] = num;
i++;
System.out.println(Arrays.toString(nums));
}
if(i == 10){
break;
}
}
}
}
数组与基本数据类型的区别
/**
* 堆栈
* 栈区是先进后出
* main方法执行后，会在栈区分配空间，
* 遇到基本数据类型，都会直接在栈区保存数据 （int i = 10）
* 遇到引用数据类型，（int[] i = {1,2,3}）,现在堆区开辟空间存储数据，然后在栈区保存堆区的地址
/
/*
* 实现数组的拷贝
* 对于有序数组的插入与删除操作本质就是数组的拷贝
/
/*
* 数组的插入
*/
实现数组的添加数据
@Test
public void test01(){
/**
* 实现数组的拷贝
* 对于有序数组的插入与删除操作本质就是数组的拷贝
*/
/**
* 数组的插入
*/
// 目标数组
int[] target;
// 原数组
int[] source = {1, 12, 23, 34};
// 需要插入的数据
int num = 56;
// 记录要插入的位置
int index = -1;
//判断出新的数组应该在那个位置
for (int i = 0; i < source.length; i++) {
if(num <= source[i]){
index = i; //找到位置，跳出循环
break;
}
}
if(index == -1){
//在数组的最后以为插入
target = Arrays.copyOf(source, source.length + 1); //把原数组赋值给新数组，并扩容一位
target[source.length] = num; //并在最后一位插入数据
}else{
//在中间插入数据
target = new int[source.length + 1];
//新数组的赋值
for(int i =0;i<target.length;i++){
//如果i < 要插入的位置 那么就全部赋值给位置
if(i < index){
target[i] = source[i];
}else if(i == index){
target[i] = num;
}else if(i > index){
target[i] = source[i - 1];
}
}
}
System.out.println(Arrays.toString(target));
}
通过Arrays和System来实现数据添加
//案例
int[] target = new int[20];
int[] source = {1, 12, 23, 34,45,56,67,78};
int num = 40;
int index = 5;
System.arraycopy(source,0,target,0,5);
target[index] = num;
System.arraycopy(source,index,target,index+1,source.length - index);
System.out.println(Arrays.toString(target));
@Test
public void test02(){
/**
* jdk中也有实现 System
*/
// 目标数组
int[] target;
// 原数组
int[] source = {1, 12, 23, 34};
// 需要插入的数据
int num = 2;
// 记录要插入的位置
int index = -1;
//判断出新的数组应该在那个位置
for (int i = 0; i < source.length; i++) {
if(num <= source[i]){
index = i; //找到位置，跳出循环
break;
}
}
if(index == -1){
//在数组的最后以为插入
target = Arrays.copyOf(source, source.length + 1); //把原数组赋值给新数组，并扩容一位
target[source.length] = num; //并在最后一位插入数据
}else{
//在中间插入数据
target = new int[source.length + 1];
//新数组的赋值
//index前面赋值
System.arraycopy(source,0,target,0,index);
//index赋值
target[index] = num;
//index
System.arraycopy(source,index,target,index+1,source.length - index);
}
System.out.println(Arrays.toString(target));
}
数组的冒泡排序
/**
* 冒泡排序
*/
@Test
public void test03(){
int[] nums = {1, 34, 23, 12, 90, 35};
int temp = 0;
for(int i=0; i<nums.length - 1; i++){
for(int j = 0; j< nums.length - 1 - i; j++){
//前面一个数大于后面一个数交换位置
if(nums[j] > nums[j+1]){
temp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = temp;
}
}
}
System.out.println(Arrays.toString(nums));
}
数组案例实操
/**
* 使用数组保存，提前先初始化一部分数据,数组长度不可以变
* 然后输入字符串，动态插入，如果数组长度不够，可以动态扩容
*/
/**
* 判断数组是否有空串
*/
public Boolean checkStringArray(String[] names){
for (String name : names) {
if ("".equals(name) || name == null) {
return true;
}
}
return false;
}
@Test
public void test04(){
String[] names = {"hehe", "zhangsan", "lisi", "wangcai"};
String[] newNames; //扩展数组
String next;
Arrays.toString(names);
System.out.println(Arrays.toString(names));
//现在就输入字符串
Scanner scanner = new Scanner(System.in);
while (true) {
System.out.print("请输入数据：");
next = scanner.next();
//判断names是否有空串
if(checkStringArray(names)){
//判断第几个为空
for(int i=0; i<names.length;i++){
if(names[i] == null || names[i].equals("")){
names[i] = next;
break;
}
}
}else{
//字符串不为空。动态扩容50%
newNames = new String[names.length + (Integer)names.length/2];
System.arraycopy(names, 0, newNames, 0, names.length);
for(int i =0;i<newNames.length;i++){
if(newNames[i] == null || newNames[i].equals("")){
newNames[i] = next;
break;
}
}
//直接覆盖原来的数组
names = newNames;
}
System.out.println(Arrays.toString(names));
}
}
