五道java小題,補更四道java小題

一:分析以下需求，並用代碼實現

    1.定義List集合，存入多個字符串

    2.刪除集合中字符串"def"

    3.然后利用迭代器遍歷集合元素並輸出

import java.util.ArrayList;
import java.util.List;

public class Topic1
{
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("dsfsd");
        arrayList.add("def");
        arrayList.add("ghdh");
        arrayList.add("fdgd");
        arrayList.add("qewr");
        for (int i = 0; i < arrayList.size(); i++) {
            if (arrayList.get(i)=="def"){
                arrayList.remove("def");
            }
        }
        System.out.println(arrayList);
    }
}

 

二:分析以下需求，並用代碼實現

1.生成10個1至100之間的隨機整數(不能重復)，存入一個List集合

2.然后利用迭代器和增強for循環分別遍歷集合元素並輸出

3.如：15 18 20 40 46 60 65 70 75 91

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Random;

public class Topic2 {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        HashSet<Integer> set = new HashSet<>();
        Random ra = new Random();
        while(set.size()<=10){
            int num = ra.nextInt(100)+1;
            set.add(num);
        }
        arrayList.addAll(set);
        System.out.println(arrayList);
    }
}

 

三:分析以下需求，並用代碼實現

1.定義List集合，存入多個字符串

2.刪除集合元素字符串中包含0-9數字的字符串(只要字符串中包含0-9中的任意一個數字就需要刪除此整個字符串)

3.然后利用迭代器遍歷集合元素並輸出

import java.util.ArrayList;
import java.util.Iterator;

public class Topic3 {
    public static void main(String[] args) {
        //1.定義List集合，存入多個字符串
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("dfsd5");
        arrayList.add("sdgd");
        arrayList.add("fgdsg");
        arrayList.add("f1ds");
        for (int i = arrayList.size()-1; i>=0; i--) {
            if(methodDelete(arrayList.get(i))==true){
                arrayList.remove(i);
            }
        }
        Iterator<String> it = arrayList.iterator();
        while (it.hasNext()){
            System.out.print(it.next()+" ");
        }

        //3.然后利用迭代器遍歷集合元素並輸出
    }

    //2.刪除集合元素字符串中包含0-9數字的字符串(只要字符串中包含0-9中的任意一個數字就
    public static boolean methodDelete(String string){
        char[] array = string.toCharArray();
        for (int i = 0; i < array.length; i++) {
            if (array[i]>=48  && array[i]<=57){
                return true;
            }
        }
        return false;
    }
}

 

四:分析以下需求，並用代碼實現

    1.統計每個單詞出現的次數

    2.有如下字符串"If you want to change your fate I think you must come to the dark horse to learn java"(用空格間隔)

    3.打印格式：

        to=3

        think=1

        you=2

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Topic4 {
    public static void main(String[] args) {
        String str = "If you want to change your fate I think you must come to the dark horse to learn java";
        String strArr[] = str.split(" ");
       /* for (int i = 0; i < strArr.length; i++) {
            System.out.print(strArr[i]+" ");
        }*/
        HashMap<String,Integer> map = new HashMap<>();
        for (String s : strArr) {
          /*  if (map.containsKey(s)){
                //存在
                Integer value = map.get(s);
                value++;
                //不停的覆蓋value值
                map.put(s,value);
            }
            else {
                //不存在
                map.put(s,1);
            }*/
          //  map.put(c,map.containsKey(c)?map.get(c)+1:1);
            map.put(s,map.containsKey(s)?map.get(s)+1:1);
        }
        Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
        for (Map.Entry<String, Integer> entry : entrySet) {
            System.out.println(entry.getKey()+"="+entry.getValue());
        }
    }
}

 

五：分析以下需求，並用代碼實現

    2.定義一個noRepeat()方法,要求對傳遞過來集合中進行元素去重

        public static void noRepeat(List<String> al){

            contains

        }

import java.util.ArrayList;
import java.util.List;

public class Topic5 {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("sdgsdg1");
        arrayList.add("sdgsdg");
        arrayList.add("sdgsdg");
        arrayList.add("sdgsdg1");
        noRepeat(arrayList);
    }
    public static void noRepeat(List<String> al){
        for (int i = 0; i < al.size(); i++) {
            //第一個元素拿出來 如果 后續有元素與之相等,就刪除.
            String first = al.get(i);
            for (int j =i+1;j<al.size();j++)
            {
                if (first.equals(al.get(j))){
                    //如果 后面與這個元素相同,就刪除后面的元素
                    al.remove(j);
                   // j--;
                }
            }
        }
        System.out.println(al);
    }

}

 補充部分:

一:簡答題:
1. &和&&的區別?
前者是不短路與 ,后者是短路與.
在編寫代碼的時候,使用a&b,即是a為假,也會對b進行判斷.
如果使用的是 a&&b,如果a為假,直接短路得出結果,不會對b進行判斷

2.數據類型有哪些?
數據類型分為:基本數據類型、引用數據類型。
基本數據類型：整數型 byte short int long 、浮點型 float double 、字符型 char、布爾型 boolean（四個類別）。
引用數據類型：字符串、數組、類、接口、枚舉、Lambda

3.成員變量和局部變量的區別(從作用域,存儲位置,初始值,三個方面進行概述)
（1）定義的位置
局部變量：在方法的小括號或者大括號
成員變量：在類中方法外

（2）作用域（范圍）
局部變量：只能在所在的方法中
成員變量：在整個類中

（3）默認值
局部變量：沒有默認值，使用之前必須先賦值，否則就報錯
成員變量：有默認值

（4）內存中的位置
局部變量：跟着方法進入棧內存
成員變量：跟着對象進入堆內存

（5）生命周期
局部變量：隨着方法的進棧而存在，隨着方法的出棧而消失，立刻回收
成員變量：隨着對象的創建而存儲，隨着對象被垃圾回收機制回收而消失，在合適的時候回收

4. 線程和進程有什么區別和聯系?

進程：是指一個內存中運行的應用程序，每個進程都有一個獨立的內存空間，一個應用程序可以同時運行多
個進程；進程也是程序的一次執行過程，是系統運行程序的基本單位；系統運行一個程序即是一個進程從創
建、運行到消亡的過程。
線程：線程是進程中的一個執行單元，負責當前進程中程序的執行，一個進程中至少有一個線程。一個進程
中是可以有多個線程的，這個應用程序也可以稱之為多線程程序。

5. 實現多線程的方式以及區別:
方式一:繼承Thread類
方式二:實現Runnable接口
如果一個類繼承Thread，則不適合資源共享。但是如果實現了Runable接口的話，則很容易的實現資源共享。
總結：
實現Runnable接口比繼承Thread類所具有的優勢：
1. 適合多個相同的程序代碼的線程去共享同一個資源。
2. 可以避免java中的單繼承的局限性。
3. 增加程序的健壯性，實現解耦操作，代碼可以被多個線程共享，代碼和線程獨立。
4. 線程池只能放入實現Runable或Callable類線程，不能直接放入繼承Thread的類。

6.start()和run方法有什么區別？
start()：該方法是在當前線程中啟動一個新的線程，而新啟動的線程會調用run()方法，同時該方法不能重復調用；
run() ：該方法和普通的方法一樣，可以重復執行，不會創建新的線程。

7.Map集合的兩種遍歷方式:
(1)第一種方式通過鍵找值,因為map中鍵是唯一的.使用keySet()方法返回Map中的所有鍵.
食用方式: Set<數據類型> keys = map.keySet();
(2)通過Entry鍵值對對象進行遍歷
食用方式:Set<Entry<類型1,類型2> entrySet = map.entrySet();
然后遍歷entrySet集合就行
for(Entry<類型1,類型2> entry: entrySet)

1.：根據需求完成代碼:

         1.定義動物類

                  屬性：

                          年齡，顏色

                  行為:

                          eat(String something)方法(無具體行為,不同動物吃的方式和東西不一樣,something表示吃的東西)

                          生成空參有參構造，set和get方法

 

         2.定義狗類繼承動物類          

                  行為:

                          eat(String something)方法,看家lookHome方法(無參數)

 

         3.定義貓類繼承動物類

                  行為:eat(String something)方法,逮老鼠catchMouse方法(無參數)

 

         4.定義Person類

                  屬性：

                          姓名，年齡

                  行為：

                          keepPet(Dog dog,String something)方法

                                   功能：喂養寵物狗，something表示喂養的東西

                  行為：

                          keepPet(Cat cat,String something)方法

                                   功能：喂養寵物貓，something表示喂養的東西

                  生成空參有參構造，set和get方法 

 

         5.定義測試類(完成以下打印效果):

                  keepPet(Dog dog,String somethind)方法打印內容如下：

                          年齡為30歲的老王養了一只黑顏色的2歲的寵物

                          2歲的黑顏色的狗兩只前腿死死的抱住骨頭猛吃

 

                  keepPet(Cat cat,String somethind)方法打印內容如下：

                          年齡為25歲的老李養了一只灰顏色的3歲的寵物

                          3歲的灰顏色的貓眯着眼睛側着頭吃魚

         6.思考：        

                  1.Dog和Cat都是Animal的子類，以上案例中針對不同的動物，定義了不同的keepPet方法，過於繁瑣，能否簡化，並體會簡化后的好處？

                  2.Dog和Cat雖然都是Animal的子類，但是都有其特有方法，能否想辦法在keepPet中調用特有方法？

定義Animal類:

package topic1;

public abstract class Animal {
    /*年齡，顏色*/
    private int age;
    private String color;
    /*eat(String something)方法(無具體行為,不同動物吃的方式和東西不一樣,something表示吃的東西)*/
    public abstract void eat(String something);
    /*    生成空參有參構造，set和get方法*/

    public Animal() {
    }

    public Animal(int age, String color) {
        this.age = age;
        this.color = color;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

Cat類

package topic1;

public class Cat extends Animal {
    @Override
    public void eat(String something) {
        System.out.println("眯着眼睛側着頭"+something);
    }
    public void CatchMouse(){
        System.out.println("貓正在抓老鼠");
    }

    public Cat() {
    }

    public Cat(int age, String color) {
        super(age, color);
    }
}

Dog類

package topic1;

public class Dog extends Animal {
    @Override
    public void eat(String something) {
        System.out.println("兩只前腿死死的抱住"+something+"猛吃");
    }
    public void lookHome(){
        System.out.println("狗正在看家");
    }

    public Dog() {
    }

    public Dog(int age, String color) {
        super(age, color);
    }
}

Person類

package topic1;

import java.text.DateFormat;

public class Person {
    /*    姓名，年齡*/
    private String name;
    private int age;
    /*行為：
            keepPet(Dog dog,String something)方法
                功能：喂養寵物狗，something表示喂養的東西
    */
  /*  public void keepPet(Dog dog,String something){
        System.out.printf("年齡為%d的%s養了一只%s顏色的%d歲的寵物",this.age,this.name,dog.getColor(),dog.getAge());
        System.out.printf("%d歲的%s的狗兩只前腿死死的包住骨頭猛吃",dog.getAge(),dog.getColor());
    }
    public void keepPet(Cat cat,String something){
        System.out.printf("年齡為%d的%s養了一只%s顏色的%d歲的寵物",this.age,this.name,cat.getColor(),cat.getAge());
        System.out.printf("%d歲的%s的貓眯着眼睛側着頭吃魚",cat.getAge(),cat.getColor());
    }*/
    public void keepPet(Object obj,String something){
        if(obj instanceof Dog){
            System.out.printf("年齡為%d的%s養了一只%s顏色的%d歲的寵物\n",this.age,this.name,((Dog) obj).getColor(),((Dog) obj).getAge());
            System.out.printf("%d歲的%s顏色的狗",((Dog) obj).getAge(),((Dog) obj).getColor());
            ((Dog) obj).eat(something);
        }
        else if ((obj instanceof Cat)){
            System.out.printf("年齡為%d的%s養了一只%s顏色的%d歲的寵物\n",this.age,this.name,((Cat) obj).getColor(), ((Cat) obj).getAge());
            System.out.printf("%d歲的%s顏色的貓",((Cat) obj).getAge(),((Cat) obj).getColor());
            ((Cat) obj).eat(something);
        }
    }

    /*生成空參有參構造，set和get方法  */

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Person(String name, int age) {

        this.name = name;
        this.age = age;
    }

    public Person() {

    }
}

測試類:

package topic1;

public class TestClass {
    public static void main(String[] args) {
        Person p = new Person("老王",30);
        Person p2 = new Person("老李",25);
        Dog dog = new Dog(2,"黑");
        Cat cat = new Cat(3,"灰");
        p.keepPet(dog,"骨頭");
        p2.keepPet(cat,"吃魚");
    }
}

2.產生10個長度為10的不能重復的字符串(里面只能出現大寫字母、小寫字母、0-9的數字)，並遍歷打印輸出       

package topic2;

import java.util.LinkedHashSet;
import java.util.Random;

public class Topic2 {
    public static void main(String[] args) {
        method3();
    }
    private static void method3() {
        LinkedHashSet<String> set = new LinkedHashSet<>();
        while(set.size()<10)
        {
            set.add(makeArray());

        }
        System.out.println(set);

    }
    /*產生長度為10的不能重復的字符串(里面只能出現大寫字母、小寫字母、0-9的數字)*/
    private static String makeArray(){
        String strValue = "";
        //1.先創建一個字符數組，題目要求長度為10，即是字符數組的上限為10
        char array[] = new char[10];
        //2.隨機生成 一個flag標記值,用來隨機生成 小寫字母 大寫字母 數字
        Random ra = new Random();
        for (int i = 0; i < array.length; i++) {
            //獲得flag標記值
            //flag為 0 標記 整數
            //flag為 1 標記 小寫字母
            //flag為 2 標記 大寫字母

            int flag = ra.nextInt(3);
            if (flag == 0)
            {
                int zhengshu = new Random().nextInt(10);
                array[i]=(char)(48+zhengshu);

            }
            else if (flag ==1){
                int xiaoxie = new Random().nextInt(26);
                array[i]=(char)('a'+xiaoxie);
            }
            else
            {
                int daxie = new Random().nextInt(26);
                array[i]=(char)('A'+daxie);
            }
        }
        for (int i = 0; i < array.length; i++) {
            strValue+=array[i];
        }
        return strValue;
    }

}

3.鍵盤錄入一個字符串,統計每個字母出現的次數（不用按照字母的順序排列），按照如下格式打印：

 * a(10)b(2000)c(30)d(400)...

package topic3;

import java.util.*;

public class Topic3 {
    public static void main(String[] args) {
        System.out.println("請輸入隨便一個字符串");
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        method1(str);



    }
    private static void method1(String str) {

        //1. 創建Map集合,key是字符串中的字符,value是字符的個數
        //由於HashMap具有篩選功能,可以幫助我們對字符進行統計.
        HashMap<Character,Integer> map = new HashMap<>();
        //2.將形式參數傳遞過來的字符串使用toCharArray()的方法轉換成Char類型的字符數組.c用來遍歷獲取字符數組中的每一個值.
        for(char c :str.toCharArray()){
            //對於字符串"abcbcd"為例,char c =a; map.containKey(a)為false,執行:號后的1
            //map.put(a,1); 這樣就將a字符與對應的數量添加到了map集合中.
            map.put(c,map.containsKey(c)?map.get(c)+1:1);
        }
       /* //獲取最后一個key
        Set<Character> chrs = map.keySet();
        List list = new ArrayList(chrs);
        char lastKey = (char)(list.get(list.size()-1));*/
        //char lastKey =  (char)list.lastIndexOf("d");
        //   System.out.println(lastKey);
        for(Map.Entry<Character,Integer> entry : map.entrySet()){
            char key = entry.getKey();
            int value = entry.getValue();
            //如果是最后一個key直接打印key與value結束.
           /* if (key == lastKey)
            {
                System.out.println(key+"="+value);
                break;
            }*/
            //如果不是最后一個,打印 key與value和一個逗號分隔
            System.out.print(key+"("+value+")");

        }

    }

}

4.分析以下需求，並用代碼實現 定義Student類包含姓名：String name、年齡：int age、成績：int

 * score，生成空參、有參構造、set和get方法、toString方法

 1.創建10個學生對象(其中有兩個學員信息完全相同)存入集合中

 2.去除重復的學員並遍歷打印剩余學員信息

 3.打印最高分的學員信息

 4.打印平均分

 5.打印不及格的學員信息及數量

創建一個Student類

package topic4;

public class Student {
    /*姓名：String name、年齡：int age、成績：int*/
    private String name;
    private int age;
    private int score;
    /*生成空參、有參構造、set和get方法、toString方法*/

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    public Student(String name, int age, int score) {

        this.name = name;
        this.age = age;
        this.score = score;
    }

    public Student() {

    }
}

測試類:

package topic4;

import java.util.ArrayList;

public class Topic4 {
    public static void main(String[] args) {
        /* 1.創建10個學生對象(其中有兩個學員信息完全相同)存入集合中*/
        ArrayList<Student> arrayList = new ArrayList<>();
        arrayList.add(new Student("學生1",18,90));
        arrayList.add(new Student("學生2",18,80));
        arrayList.add(new Student("學生3",18,70));
        arrayList.add(new Student("學生4",18,60));
        arrayList.add(new Student("學生5",18,50));
        arrayList.add(new Student("學生6",18,40));
        arrayList.add(new Student("學生7",18,30));
        arrayList.add(new Student("學生8",18,20));
        arrayList.add(new Student("學生9",18,10));
        arrayList.add(new Student("學生1",18,90));
        /*2.去除重復的學員並遍歷打印剩余學員信息*/
        int delFlag =0;//重復刪除元素標記
        int highScoreFlag=0;//最高分標記
        int count=0;//總成績
        for (int i = 0; i < arrayList.size(); i++) {
            for(int j=1;j<arrayList.size();j++){
                if (arrayList.get(i)==arrayList.get(j))
                {
                    delFlag=j;
                }
            }

        }
        //刪除重復學員
        arrayList.remove(delFlag);
        for (Student student : arrayList) {
            System.out.println(student);
        }
       // 3.打印最高分的學員信息
        int score = arrayList.get(1).getScore();
        for (int i = 1; i < arrayList.size(); i++) {
            if (arrayList.get(i).getScore()>score)
            {
               // score=arrayList.get(i).getScore();
                highScoreFlag=i;
            }
        }
        System.out.println("最高分的學員為"+arrayList.get(highScoreFlag));
        // 4.打印平均分
        for (int i = 0; i < arrayList.size(); i++) {
            count+=arrayList.get(i).getScore();
        }
        System.out.println("平均分為"+(double)count/(double)arrayList.size());
        // 5.打印不及格的學員信息及數量
        int bujigeCount=0;
        System.out.println("不及格的人為:");
        for (int i = 0; i < arrayList.size(); i++) {
            if (arrayList.get(i).getScore()<60)
            {
                System.out.print(arrayList.get(i).getName()+"  ");
                bujigeCount++;
            }
        }
        System.out.println("不及格的總人數為"+bujigeCount);
    }
}