java 入门简易题（冒泡排序法）

﹏ヽ暗。殇╰゛Y 2023-07-22 12:25 1阅读 0赞

## 1.99乘法表 ##

/**
     * 使用for循环
     */
    public class 九九乘法表 {
        
    	public static void main(String[] args) {
        
    		//方法一：使用for循环：
    		System.out.println("方法一：");
    		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();
    		}
    		//分割线：
    		System.out.println("=================================================================================");
    		
    		//方法二：使用while循环：
    		System.out.println("方法二：");
    		int i=1;
    		while(i<=9){
        
    			int j=1;
    			while(j<=i) {
        
    				System.out.print(i+"*"+j+"="+i*j+"\t");
    				j++;
    			}
    			System.out.println();
    			i++;
    		}
    	}
    }

## 2.定义长度为100的定长数组，每个元素为随机生成的0~9之间的数，统计每个数出现的次数。 ##

/**
     *  关键词：定义长度为100的定长数组，每个元素为随机生成的0~9之间的数，统计每个数出现的次数。
     */
    import java.util.Arrays;
    
    public class 获取随机数组中每个元素出现的次数 {
        
    	public static void main(String[] args) {
        
    		java.util.Random Random=new java.util.Random();
    		int[] array=new int[100];
    		for(int i=0;i<array.length;i++) {
        
    			array[i]=Random.nextInt(10);//生成随机数，并且把随机数放到数组中去
    		}
    		System.out.println("生成的数组是：" );//打印数组
    		System.out.println(Arrays.toString(array));
    		
    		int[] times=new int[array.length];  //定义一个用来存放每个数出现次数的数组
    		for(int i=0;i<10;i++) {
        				//统计每个数出现的次数
    			for(int j=0;j<array.length;j++) {
        
    				if(i==array[j]) {
        
    					times[i]++;
    				}
    			}
    		}
    		
    		//输出次数数组
    		for(int i=0;i<10;i++) {
        
    			System.out.println(i+"出现了"+times[i]+"次！");
    		}
    	}
    }

## 3.统计1~1000以内的质数 ##

/**
     *  关键词：统计1~1000以内的质数
     *  1.质数：只能被1或它自身整除的数；
     *  2.除了2以外的所有偶数都不是质数；
     *  3.1不是质数；
     *  
     */
    public class 统计质数 {
        
    	public static void main(String[] args) {
        
    		System.out.println("1至1000以内的质数如下：");
    		System.out.print(2+"\t"); 
    		
    		int time=1,flag=1;//定义两个变量分别用来帮助统计次数和控制输出结果每行的个数
    		
    		//定义一个标识符：OUT
    		OUT:
    		
    		for(int i=3;i<=1000;i+=2) {
        //第一层循环
    			for(int j=2;j<i;j++) {
        //第二层循环
    				if(i%j==0) {
        
    					continue OUT;//使用标识符：OUT,结束第一层的本次循环，让第一层循环体进入下一次循环
    				}
    			}
    			if(flag%30==0) {
        //每行输出30次结果（falg能被30整除）的时候，换行
    				System.out.println();
    				flag=0;
    			}
    			time++;
    			flag++;
    			System.out.print(i+"\t");
    		}
    		
    		System.out.println();
    		System.out.println("质数总个数为："+time);
    	}
    }

## 4.录入值排序： （冒泡排序法） ##

/**
     * @author Aurora
     * 关键词：先输入一个整数n，后输入n个整数进行排序，输出排序后的数组
     *  
     */
    
    import java.util.Arrays;
    
    public class 排序 {
        
    	public static void main(String[] args) {
        
    		 java.util.Scanner s=new java.util.Scanner(System.in);
    		 System.out.println("输入需要排序数组的个数：");
    		 int x=s.nextInt();
    		 int n[]=new int[x];
    		 System.out.println("输入需要排序的数：");
    		 for(int i=0;i<x;i++) {
        //录入数组的值
    			 n[i]=s.nextInt();
    		 }s.close();
    		 //排序前输出数组的值：
    		 //方法一：
    		 System.out.println("排序前：");
    		 System.out.println(Arrays.toString(n));
    		 for(int i=0;i<n.length-1;i++) {
        
    				for(int j=0;j<n.length-1-i;j++) {
        
    					if(n[j]>n[j+1]) {
        
    						int tmp=n[j];
    						n[j]=n[j+1];
    						n[j+1]=tmp;
    					}
    				}
    			}
    		 System.out.println("=====================================================================");
    		 System.out.println("排序后：");
    		 System.out.println(Arrays.toString(n));
    	}
    }

## 5.给出一个自然数n，求出1到n之间的数组成不重复的三位数 ##

/**
     * @author Aurora
     * 要求：给出一个自然数n，求出1到n之间的数组成不重复的三位数，如：给定n=4,即有：[1,2,3,4],
     * 		合法的有：123,124,134,234...等等，如：111,222...便不合法；
     *  
     */
    import java.util.Scanner;
    
    public class 不同数的组合 {
        
    	public static void main(String[] args) {
        
    		Scanner s=new Scanner(System.in);
    		int n=s.nextInt();
    		s.close();
    		int num=0;
    		for(int i=1;i<=n;i++) {
        
    			for(int j=1;j<=n;j++) {
        
    				for(int k=1;k<=n;k++) {
        
    					if(i!=j&&j!=k&&k!=i) {
        
    						int date=i*100+j*10+k;
    						System.out.println( date+" ");
    						num++;
    					}
    				}
    			}
    		}
    		System.out.println("总个数："+num);
    	}
    }

## 6.第5题拓展(数组版)：先输入一个n，再给出n个数，求出这n个数随机组成的所有三位数 ##

/**
     * @author Aurora
     * 要求：先输入一个n，再给出n个数，求出这n个数随机组成的所有三位数，如：给定n=4,即有：[1,2,3,6],
     * 		合法的有：123,126,136,236...等等，如：111,222...便不合法；
     *  
     */
    
    import java.util.Scanner;
    
    public class 不同数的组合数组版 {
        
    	public static void main(String[] args) {
        
    		Scanner s=new Scanner(System.in);
    		int n=s.nextInt();
    		int[] a=new int[n];
    		for(int i=0;i<a.length;i++) {
        
    			a[i]=s.nextInt();
    		}
    		s.close();
    		int num=0;
    		for(int i=0;i<a.length;i++) {
        
    			for(int j=0;j<a.length;j++) {
        
    				for(int k=0;k<a.length;k++) {
        
    					if(a[i]!=a[j]&&a[j]!=a[k]&&a[k]!=a[i]) {
        
    						int date=a[i]*100+a[j]*10+a[k];
    						System.out.println( date+" ");
    						num++;
    					}
    				}
    			}
    		}
    		System.out.println("总个数："+num);
    	}
    
    }

## 7.随机生成10个不重复的1~20（不包括20）之间的数，输出排序后的数组：由小至大；由大至小； ##

## 冒泡排序法： ##

/**
     * @author Aurora
     *   要求：随机生成10个不重复的1~20（不包括20）之间的数，输出排序后的数组：由小至大；由大至小；
     *  
     */
    import java.util.Arrays;
    import java.util.Random;
    
    public class 冒泡排序 {
        
    	public static void main(String[] args) {
        
    		Random Ran=new Random();
    		int []a=new int[10];
    		OUT:
    		for(int i=0;i<a.length;i++) {
        
    			int date=Ran.nextInt(20);
    			for(int j=0;j<a.length;j++) {
        
    				if(a[j]==date) {
        
    					 i--;
    					continue OUT;
    				}
    			}
    			a[i]=date;
    		}
    		System.out.println("排序前数组中的信息："+Arrays.toString(a));
    		for(int i=0;i<a.length-1;i++) {
        
    			for(int j=0;j<a.length-1-i;j++) {
        
    				if(a[j]>a[j+1]) {
        
    					int temp=a[j];
    					a[j]=a[j+1];
    					a[j+1]=temp;
    				}
    			}
    		}
    		System.out.println("由小往大排序后数组中的信息："+Arrays.toString(a));
    		for(int i=0;i<a.length-1;i++) {
        
    			for(int j=0;j<a.length-1-i;j++) {
        
    				if(a[j]<a[j+1]) {
        
    					int temp=a[j];
    					a[j]=a[j+1];
    					a[j+1]=temp;
    				}
    			}
    		}
    		System.out.println("由大往小排序后数组中的信息："+Arrays.toString(a));
    	}
    }