循环，数组，快排，冒泡，类的调用

1.考试成绩已经保存在数组scores中，依次为 :89,23,64,91,119,52,73,-23 要求根据通过自定义方法来找出其中前三名，将数组成绩作为参数传入 要求判断成绩的有效性(0-100),如果成绩无效，则忽略此成绩.

pakage aa;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Main{
            //static List<Integer> list=new ArrayList<Integer>();
            public static void main(String[] args){
            //创建数组，保存考试成绩
            int[] scores=new int[] {89,23,64,91,119,52,73,-23};
            selectSort(scores);//调用排序
            printSort(scores);//打印出前三的成绩
            //p1(scores);
            }
            //选择排序，对数组成绩进行排序
            public static void selectSort(int[] arr){
                for(int x=0;x<arr.length-1;x++){
                    int num=arr[x];//定义临时变量记录成绩
                    int index=x;//定义变量记录成绩的索引
                    for(int y=x+1;y<arr.length;y++){
                        if(num<arr[y]){
                            num=arr[y];
                            index=y;
                        }
                    }
                    if(index!=x){
                        int temp=arr[x];
                        arr[x]=arr[index];
                        arr[index]=temp;
                    }
                }   
            }
            //创建打印成绩的方法
            public static void printSort(int[] arr){
                System.out.print("班级前三的成绩为:");
                int count=0;//定义变量，限制成绩打印个数
                for(int x=0;x<arr.length;x++){
                    if(arr[x]>100||arr[x]<0){
                            continue ;
                    }
                     if(x!=arr.length-1){
                        System.out.print(arr[x]+" ");
                    }else{
                        System.out.print(arr[x]);
                    }
                     count++;
                     if(count>2){
                         break;
                     }

                }
            }

            /*public static void p1(int[] arr){


                 for (int i = 0; i <arr.length; i++) {
                    if(arr[i]>100&&arr[i]<0)
                        continue;
                    else if(arr[i]<=100&&arr[i]>0){
                        list.add(arr[i]);
                    }
                    }
                 for (int i = 0; i <list.size(); i++) {
                    System.out.print(list.get(i)+" ");
                }
                 }*/
            }

2.用数组来实现， 定义并初始化一个（1–100）保存100个数的数组，从第一个元素开始，依次数(1,2,3 循环往复),每次数到到3的元素淘汰掉.当到达数组 末尾的时候再从头开始，直到最后剩余一个元素，写出算法，并输出最后保留的元素所在的最初的位置.

package aa;


public class Test {
    public static void main(String[] args){
        int[] arr=new int[100];//创建数组，用于保存1~100
        initArr(arr);//初始化数组
        function(arr);
    }
    //创建初始数组方法
    public static void initArr(int[] arr){
        for(int i=0;i<arr.length;i++){
            arr[i]=i+1;
        }
    }
    public static void function(int[] arr){
        int length=arr.length;//记录数组的有效长度
        while(length>2){
            for(int i=2;i<length;i=i+3)//标记要淘汰的数组成员
            {
                  arr[i]=0;         
             }
            for(int i=0;i<length;i++){
                if(arr[i]==0){
                    for(int j=i;j<length-1;j++){
                         arr[j]=arr[j+1];//覆盖淘汰的数值
                    }
                    length--;//更新数组的有效长度
                }
                //标记重排后要淘汰的数组成员
                if(arr[i]==100){
                    for(int i1=2;i1<length;i1=i1+3){
                               arr[i1]=0;         
                     }
                }
            }
        }
        System.out.println("最后剩下的元素为：");//打印最后的元素
        for(int i=0;i<length;i++){
           System.out.print("["+(arr[i]-1)+"]="+arr[i]+",");
        }
    }
}

3. 用数组来实现对于一个整形数组， 分别通过冒泡排序和 快速排序，实现对于任意一个数组进行由小到大的排列。

package aa;

public class Sort {     
    public static void main(String[] args){
        System.out.print("请输入数组长度:");
        Scanner scan=new Scanner(System.in);
        int i=scan.nextInt();//接收数组长度
        int[] arr=new int[i];
        for(int j=0;j<i;j++){
            arr[j]=scan.nextInt();
        }
        bubbonSort(arr);
        quikSort(arr,0,arr.length-1);
        printArr(arr);
    }
    //构造打印数组的方法
    public static void printArr(int[] arr){
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }
    //冒泡排序
    public static void bubbonSort(int[] arr){
        for(int i=arr.length-1;i>0;i--){
            for(int j=0;j<i;j++){
                if(arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
    }
    //快速排序
    public static void quikSort(int[] arr ,int left, int right){
        if(left<right){
            int pivotkey=arr[left];//定义变量，记录键值
            int low=left;//定义低位指针
            int high=right;//定义高位指针
            while(low<high){
            //高位指针扫描
                while(low<high&&arr[high]>pivotkey){
                    high--;
                }
                arr[low]=arr[high];
            //低位指针扫描
                while(low<high&&arr[low]<pivotkey){
                    low++;
                }
                 if(low < high)//避免堆栈溢出
                           arr[high--] = arr[low];//--避免死循环 
            }
            arr[low]=pivotkey;//将键值移到最终位置
            quikSort(arr,left,high-1);//键值的左侧进行快排
            quikSort(arr,high+1,right);//键值的右侧进行快排
        }   
    }
}

4.判断101-200之间有多少个素数，并输出所有素数。

package aa;

public class Prime_Number {
    public static void main(String[] args){
        int count=0;//定义变量，记录素数个数
        for(int i=101;i<=200;i++){
            if(i%2!=0){
                count++;
                System.out.print(i+" ");
            }
        }
        System.out.println();//分隔素数与素数个数
        System.out.println(count);
    }
}

5.题目：输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。

package aa;

import java.util.Scanner;

public class Prime_Number {
    public static void main(String[] args){
        Scanner scan=new Scanner(System.in);
        statistics(scan.nextLine());//调用判断方法
    }
    public static void statistics(String str){
        int letter = 0,space=0,number=0,other=0;
        for(int i=0;i<str.length();i++){
            char ch = str.charAt(i);//charAt() 方法用于返回指定索引处的字符。索引范围为从 0 到 length() - 1。
            if(ch>'A'&&ch<'Z'||ch>'a'&&ch<'z'){
                letter++;
            }else if(ch==' '){
                space++;
            }else if(ch>='0'&&ch<='9'){
                number++;
            }else{
                other++;
            }
        }
    System.out.print("字母个数:"+letter+"\n"+"空格个数:"+space+"\n"+"数字个数:"+number+"\n"+"其他字符个数:"+other);
    }
}

7.分别定义用户类，订单类，产品类，其中订单类至少要具有下订单的行为(入参为一个产品名称)

产品类中至少有一个成员变量为产品名称，至少有一个方法用来获取产品的名称。 用户类中持有一个产品类型的成员变量。用户类中持有一个订单类型的成员变量。在我们的用户类中定义main函数，当执行的时候，构造一个用户类的对象， 并且通过手段可以拿到产品成员变量中的产品名称，并且调用成员变量订单的对象，进行下单。 最后输出下单成功。

package aa;

public class User {
    Protect pro=new Protect();
    Order ord=new Order();
    public static void main(String[] args){
        User user=new User();
        String name=user.pro.getName();
        user.ord.place_Order(name);
    }
}
class Protect{
    String protect_name="iPhone8 plus";
    public String getName(){
        return protect_name;

    }
}
class Order{
public void place_Order(String name){
        System.out.print("恭喜您:"+" \""+name+"\" "+"下单成功");
    }
}