数组

 

程序=算法+数据结构
1.算法：解决问题的流程/步骤（顺序、分支、循环）
2.数据结构：将数据按照某种特定的结构来保存
数怎么存
设计良好的/合理的数据结构会导致好的算法

 

开关算法：

 

 

package day06;

import java.util.Scanner;

public class PrimeNumber {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		System.out.print("请输入查找的质数范围：2~");
		int num = scan.nextInt();
		int n = 0;
		for (int i = 2; i <= num; i++) {
			//开关算法
			boolean flag = true;//1.假设是质数
			for(int a=2;a<=Math.sqrt(i);a++) {
				if(i%a==0) {
					flag=false;//2.修改为不是质数
					break;
				}
			}
			if (flag) {//3.判断得结论
				n += 1;
				System.out.print(i + " ");
				if(n%10==0) {
					System.out.println();
				}
			}
		}
		System.out.println();
		System.out.println("共有"+n+"个质数");
		scan.close();
	}
}

 

效果如图：

 

 

数组：
1.数组是相同数据类型的元素组成的集合
2.数组是一种数据类型（引用数据类型）
3.数组的定义：
int[] arr = new int[10];
一.数组的初始化：
int[] arr = new int[4];//0 0 0 0
int[] arr = {1,4,6,8};//1 4 6 8
int[] arr = new int[]{1,4,6,8};//1 4 6 8
int[] arr;
arr = {1,4,6,8};//编译错误
arr = new int[]{1,4,6,8};//1 4 6 8
二.数组的访问：
1.通过（数组名，length）来获取数组的长度
int[] arr = new int[4];
System.out.println(arr.length);
2.通过下标/索引来访问数组中的元素
下标从0开始，最大到（数组.length-1）
int[] arr = new int[3];
arr[0] = 100;//给arr中第1个元素赋值为100
arr[1] = 200；//给arr中第2个元素赋值为200
arr[2] = 300；//给arr中第3个元素赋值为300
arr[3] = 400；//数组下标越界异常
System.out.println(arr[arr.length-1]);
三.数组的遍历：
int[] arr = new int[10];
for ( int i = 0 ; i < arr.length ; i ++ ){
    arr [ i ] = 100;
}


int [ ] arr = new int [ 5 ] {10,20,30,40,50 } ;   //正序输出
for ( int i=0; i< arr.length; i++) {
    System.out.println ( arr[ i ] ) ;
}


int [ ] arr = new int [ 5 ] {10,20,30,40,50 } ;    //逆序输出
for ( int i = (arr.length -1) ; i >= 0 ; i - - ) {
  System.out.println ( arr[ i ] ) ;
}
四.数组的复制：
1.System.arraycopy( a , 1 , a1 , 0 , 4 ); //灵活、效率高
（源数组，源数组的起始下标，目标数组，目标数组的起始下标，要复制的元素的个数）
2.数组的扩容
int [ ]  a1 = Arrays . copyOf ( a, 6 );  //不灵活、效率低
（源数组，要复制的元素的个数）——>从第一个元素开始复制


a = Arrays . copyOf (  a, a.length+1 );-->数组长度加1，最后一个值0

 

 

package day06;

import java.util.Arrays;

public class Array {
	public static void main(String[] args) {
		int[] a = {10,20,30,40,50};
		int [ ]  a1 = Arrays . copyOf ( a, 3 );  //不灵活、效率低
		for(int i=0;i<a1.length;i++){
			System.out.println(a1[i]);
		}
	}
}

 

效果如图：

 

查询数组最小值，并将数组扩容形成新数组：

 

 

 

package day06;

public class MinOfArray {
	public static void main(String[] args) {
		int[] arr = new int[10];
		System.out.print("数组中的数据为：[");
		for(int i=0;i<arr.length-1;i++) {
			arr[i] = (int)(Math.random()*100);
			System.out.print(arr[i]+",");
		}
		arr[arr.length-1] = (int)(Math.random()*100);
		System.out.println(arr[arr.length-1]+"]");
		int min = arr[0];
		for(int i=1;i<arr.length;i++) {
			if(arr[i]<min) {
				min=arr[i];
			}
		}
		System.out.println("最小值是："+min);
		int[] arr1=new int[11];
		System.arraycopy( arr , 0 , arr1 , 1 , 10 ); 
		arr1[0]=min;
		System.out.print("新数组中的数据为：[");
		for(int i=0;i<arr1.length-1;i++) {
			System.out.print(arr1[i]+",");
		}
		System.out.println(arr1[arr1.length-1]+"]");
	}
}

 

效果如图：

 

五.数组的排序：
1.long a = System.currentTimeMillis();
  Arrays.sort(arr);//升序排序
  long b = System.currentTimeMillis();
  System.out.println(b-a);//排序时间
2.冒泡算法：
（1）4个数冒3轮
（2）每一轮都是从第1个元素开始冒，每一次都是和它的下一个元素比
（3）冒出来就不用管

 

 

 

package day06;

public class BubbleSort {
	public static void main(String[] args) {
		int[] arr = new int[10];
		for(int i=0;i<arr.length;i++) {
			arr[i] = (int)(Math.random()*100);
			System.out.print(arr[i]+" ");
		}
		for(int i=0;i<arr.length-1;i++) {//控制轮
			for(int j=0;j<arr.length-1-i;j++) {//控制次
				if(arr[j]>arr[j+1]) {//和它下一个元素比
					int t= arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=t;
				}
				//若前数大于后数则交换，保证前数小于后数----升序
				//若前数小于后数则交换，保证前数大于后数----降序
			}
		}
		System.out.println("排序后为：");
		for(int i=0;i<arr.length;i++) {
			System.out.print(arr[i]+" ");
		}
	}
}

效果如图：