数组

1. 数组的定义

int[] arr1=new int[10];

2. 数组的初始化

		int[] arr2=new int[4];
		int[] arr3={1,4,5,7};
		int[] arr4=new int[]{1,4,5,7};
		int[] arr5;
		//arr5={1,4,5,7};//编译错误，只能声明同时
		arr5=new int[]{1,4,5,7};

3. 数组的访问

		int[] arr6=new int[3];
		System.out.println(arr6.length);//3
		arr6[0]=100;//给第一个元素赋值为100
		arr6[1]=200;//给第二个元素赋值为200
		arr6[2]=300;
		//arr6[3]=400;//数组下标越界异常
		System.out.println(arr6[arr6.length-1]);

4. 数组的遍历

		int[] arr7=new int[10];
		for(int i=0;i<arr7.length;i++){
			arr7[i]=(int)(Math.random()*100);
		}
		for(int i=0;i<arr7.length;i++){
			System.out.print(arr7[i]+"\t");
		}

5. 数组的复制

//(1) Arrays.copyOf()
		    int[] a={10,20,30,40,50};//a:源数组 a1:目标数组  6：目标数组的长度
		 	int[] a1=Arrays.copyOf(a, 6);
			for(int i=0;i<a1.length;i++){
				System.out.println(a1[i]);//10,20,30,40,50,0
			}
//还可以用来给数组扩容
			 int[] a={10,20,30,40,50};
			 a=Arrays.copyOf(a,a.length+1);//这里的a是一个新的数组，长度为之前的加一。如果想扩大两个就加二，想减小一个就减一。。这个a和上面的a不一样，将源数组中的内容复制过来
			 for(int i=0;i<a.length;i++){
				System.out.println(a[i]);//10,20,30,40,50,0
				}
				
//(2) arraycopy()	灵活性更好 效率更高	
				int[] a={10,20,30,40,50};
				int[] a1=new int[6];//0,0,0,0,0,0
				System.arraycopy(a, 1, a1, 0, 4);
				//a:源数组   1:源数组的起始下标    a1:目标数组   0：目标数组的起始下标   4：要复制元素的个数
				for(int i=0;i<a1.length;i++){
					System.out.println(a1[i]);//20,30,40,50,0,0
					}

6. 数组的排序Arrays.sort()效率最高

				int[] arr={10,45,4,2,6,75,345,24};
				Arrays.sort(arr);
				for(int i=0;i<arr.length;i++){
					System.out.print(arr[i]+"\t");
				}

7. 找数组中的最大值

   找最大值的算法：
 * 1.假设第一个元素为最大值
 * int max=arr[0];
 * 2.遍历剩余元素，将剩余元素与max做对比，若剩余元素大于max，修改max为较大的数
 * for(int i=1;i<arr.length;i++){
 * 	if(arr[i]>max){
 * 		max=arr[i]
 * 		}
 * 	}

		int[] arr=new int[10];
		for(int i=0;i<arr.length;i++){
			arr[i]=(int)(Math.random()*100);
		}
		for(int i=0;i<arr.length;i++){
			System.out.print(arr[i]+"\t");
		}
		int max=arr[0];//假设第一个元素为最大值
		for(int i=1;i<arr.length;i++){//遍历剩余元素，将剩余元素与max做对比
			if(arr[i]>max){//若剩余元素比max大
				max=arr[i];//修改max为较大的值
			}
		}
		System.out.print("最大值为："+max+"\t");
		System.out.println("长度为："+arr.length);
		arr=Arrays.copyOf(arr, arr.length+1);//扩容
		arr[arr.length-1]=max;//将最大值赋值给最后一个元素
		for(int i=0;i<arr.length;i++){
			System.out.print(arr[i]+"\t");
		}
		System.out.println("长度为："+arr.length);

冒泡排序
冒泡的工作原理：
（1）四个数冒三轮
（2）每一轮都是从第一个元素开始冒
每一次都是和它的下一个元素比较
（3）冒出来的数就不带它玩了

		int[] arr=new int[4];
		for(int i=0;i<arr.length-1;i++){//控制轮数  4个数冒3轮
			for(int j=0;j<arr.length-1-i;j++){//控制每一轮的次数         
				//i=0  比3次 ，i=1 比2次，i=2 比1次  次数=arr.length-1-i
				if(arr[j]>arr[j+1]){//每一次都是和他的下一个元素比
					int t=arr[j];//如果这个数比他的下一个元素大，则交换，保证前数小于后数（升序）
					arr[j]=arr[j+1];
					arr[j+1]=t;
					//若要为降序，则arr[j]<arr[j+1]
				}
			}
		}

			for(int i=0;i<arr.length;i++){
				System.out,println(arr[i]);
			}

九九乘法表

		for(int i=1;i<=9;i++){//控制行
			for(int j=1;j<=i;j++){//控制列
				System.out.print(i+"*"+j+"="+i*j+"\t");
			}
			System.out.println();//换行
		}

判断一个数是否是质数

		int num=100;
		boolean flag=true;//1.假设是质数
		/*整个for循环结束都没有进到if里面，说明是质数
		只要进到if里面，就说明不是质数
		for(int i=2;i<num;i++){//2 3 4 5 6 7 8···99
    	100去取余（一半以后）51 52 53··· 99都是没有意义的，因为商不到2，所以基本都是商1余某数，所以肯定不得0*/
		//优化方案1：for(int i=2;i<=num/2;i++){//对前一半的数取余，注意取等，取等的时候商2，  2 3 4 5···50
		for(int i=2;i<=Math.sqrt(num);i++){//优化方案2：对他的平方根之前的数取余2 3 4 5 ···10
		if(num%i==0){
				flag=false;//2.改为不是质数
				break;
			}
		}
		if(flag){//3.判断得出结论  作用等于 if(flag==true)----> if(!flag)相当于if(flag==false)
			
			System.out.println(num+"是质数");
		}else{
			System.out.println(num+"不是质数");
		}
	
	

求2到100之间的质数----常见的面试题

		int count=0;//---质数的个数 计数器
		for(int num=2;num<=100;num++){
			boolean flag=true;
			for(int i=2;i<=Math.sqrt(num);i++){
				if(num%i==0){
						flag=false;
						break;
					}
				}
				if(flag){
					count++;//质数个数增1
					System.out.print(num+"\t");
					if(count%10==0){
						System.out.println();
					}
				}
		}