ArrayList常见练习题解析

写个堆排

已于 2022-12-29 13:59:03 修改

阅读量634

点赞数 2

文章标签： java 开发语言

于 2022-12-26 13:02:56 首次发布

本文链接：https://blog.csdn.net/weixin_61518137/article/details/128443029

版权

 public static boolean isAdmin(String string){
        return string.toLowerCase()=="admin";
    }
    public static void main(String[] args) {
        System.out.println(isAdmin("Admin"));
    }
""引起来的是在字符串常量池里面，在String类的方法中，几乎涉及到修改String类的都最终创建了一个新的String对象，==比较的是地址

这个boolean表达式输出的结果是:
boolean b=true?false:true=true?false:true;

System.out.println(b);
这个boolean表达式输出的结果是:boolean b=true? false: true==true?false:true；

1)表达式1为true，所以返回表达式2的值，也就是false

2)现在假设这个表达式的值变成了这样:boolean b=false?false:true==true?false:true;

表达式1的值是false，所以最终结果是表达式3的值:true==true?false:true；

3)true==true?false:true;这个表达式1的值是true，所以说最终结果的值就是表达式2的值，结果还是false

封装的主要作用就是对外隐藏类内部的实现细节，增强程序的安全性

练习题一：输入:str1=abcqweracb 输出:abcqwer

1)先创建出一个StringBuilder对象，再进行遍历str这个字符串里面的字符，如果里面有str1中的字符，就不会进行拼接，如果没有，就进行拼接；但是仍然要注意一个事情

2)StringBuilder没有contains方法，只有String类才有contains方法，contains方法里面的内容必须是字符串

3)这是不能够使用HashSet的，因为要按照字母的顺序来进行输出

4)我们利用哈希的思想，我们定义一个找整型数组，来进行标记这个字符是否出现过，出现过就把它对应的下标的值变成1，下次同样的字符来了之后，只要不是0就不是我想要的

5)因为题目中给的都是大写字母和小写字母，ASCILL码表范围就是65-122

hasNext()方法会判断接下来是否有非空字符.如果有,则返回true,否则返回false
hasNextLine() 方法会根据行匹配模式去判断接下来是否有一行(包括空行),如果有,则返回true,否则返回false
比如前面用hasNextLine()，那么后面要用 nextLine() 来处理输入;

 public static void main(String[] args) {
      Scanner scan=new Scanner(System.in);
      String str=scan.next();
     StringBuilder sb=new StringBuilder();
   for(int i=0;i<str.length();i++)
   {    char ch=str.charAt(i);
      if(!sb.toString().contains(ch+""))
      {
         sb.append(ch);
      }
   }
   System.out.println(sb.toString());

   }

1)这个题本质上就是一个去重操作，这里面的数组下表就相当于是字符对应的ASCILL码表，数组下标的值就相当于这个元素出现了几次

2)我们遍历这个字符串，如果发现他的数组下标对应的元素是0，那么直接拼接到

stringBuilder里面，并将数组下标的值进行加加

3)如果这个字符对应的数组下标不是0那么说明之前出现过，就不用管了

我们定义一个整型数组，来进行标记这个字符是否出现过，出现过就把他变成1，下一次当同样的字符来了之后，只要不是0，那么就不是我想要的

array[ch-65]==>ch 'A'->[0]

array[ch-65]==>ch 'Z'->[35]

array[ch-65]==>ch 'a'->[32]

array[ch-65]==>ch 'z'->[57]

所以数组的长度就是58

  public static void main(String[] args) {
        Scanner scan=new Scanner(System.in);
        String str= scan.next();
        StringBuilder builder=new StringBuilder();
        int[] array=new int[58];
        for(int i=0;i<str.length();i++)
        {
            char ch=str.charAt(i);
            if(array[ch-65]==0)
            {
              //说明此时是第一次出现
                builder.append(ch);
                array[ch-65]=1;
            }else{
                array[ch-65]++;
            }
        }
        System.out.println(builder);
    }

练习题二:一个学校中有若干学生(学生对象放在一个List中，每一个学生有一个姓名，班级，和考试成绩的属性，某次考试成绩结束之后，每一个学生都获得了一个考试成绩，遍历List集合,把每一个学生对象的属性都打印出来；

List是可以存放自定义类型的
class Student{
   String name;
   String classes;
   double score;

   public Student(String name, String classes, double score) {
      this.name = name;
      this.classes = classes;
      this.score = score;
   }

   @Override
   public String toString() {
      return "Student{" +
              "name='" + name + '\'' +
              ", classes='" + classes + '\'' +
              ", score=" + score +
              '}';
   }
}
class test {
   public static void main(String[] args) {
      List<Student> list=new ArrayList<>();
      list.add(new Student("bit1","java100",90.3));
      list.add(new Student("bit2","java101",100.5));
      list.add(new Student("bit3","java102",31.7));
      System.out.println(list);

   }

List<String> list1=new ArrayList<>();

ArrayList<String> list2=new ArrayList<>();

上面两种方法有什么区别呢？

1)此时list1可使用的方法没有list2可使用的方法多，当借口引用引用实例化对象的时候，只能调用接口中特有的方法，不能调用ArrayList本身包含的(特有的方法)

2)也就是说父类引用引用子类对象，只能通过父类引用调用我们父类自己的方法(除非重写)，不能调用子类的

练习题三:删除第一个字符串中出现的第二个字符串中的字符；

例如 String str1=" welcome to bit";

String str2="come"

输出的结果是wl t bit

我们可以使用一个集合类list来进行操作,我们使用for循环进行循环遍历str1中的字符串中的字符，如果str2不包含着这个字符，那么就可以把这个放到List中，最终打印我的这个List即可

在这里面我们要注意一个事情,contains(里面放的是字符串类型而不是字符类型)
String str1="welcome to bit";
     String str2="come";
     ArrayList<Character> list=new ArrayList<>();
     for(int i=0;i<str1.length();i++)
     {  
      char ch=str1.charAt(i);
        if(!str2.contains(ch+""))
        {
           list.add(ch);
        }
     }
     System.out.println(list);
   }
//我们在这里面直接进行遍历str1中的字符串的字符,如果这个字符在str2中出现过,那么就进行舍弃,否则直接拼接到StringBulider里面
    public static void main(String[] args) {
      String str1="welcome to bit";
      String str2="come";
      StringBuilder stringBuiler=new StringBuilder();
      for(int i=0;i<str1.length();i++)
      {
          char ch=str1.charAt(i);
          if(!str2.contains(ch+""))
          {
              stringBuiler.append(ch);
          }
      }
      System.out.println(stringBuiler.toString());
    }

练习题四:有一个List当前存放的是整形的数据，运用Collections.sort对list进行排序

 ArrayList<Integer> list=new ArrayList<>();
      list.add(10);
      list.add(11);
      list.add(7);
      Collections.sort(list);
      System.out.println(list);

练习题五:实现一个扑克牌的功能

构建一副扑克牌:每一张牌是由数字和花色构成的

揭牌:

1)一张扑克牌就是一个对象，我们使用Card对象来进行描述一张牌，那么一副牌我们就用一个ArrayList来进行表示

2)我们在进行创建一个类，通过BuyCard方法来进行买一符牌，生成一副牌，我们还要创建一个List表来存放所有的扑克牌

3)洗牌的过程:假设我有100张牌，我想洗最后一张牌，就随机生成前面的一张牌进行交换，我从后面向前面进行遍历,我可以Random random=new Random();

从数组的最后一个位置开始逐渐向前遍历，现在得到位置是index，就随机生成0-index数组下标的牌进行交换

int index=random.nextInt(100),我想办法生成一个0-100的下标，将这个100的下标与前面的牌进行交换；

4)如果从前面向后进行交换，后面下标的值是没有办法确定的

nextInt(a)----->[0，a]；

class Card{
   private int rank;
   private String suit;
   public Card(int rank,String suit)
   {
      this.rank=rank;
      this.suit=suit;
   }
   public String toString()
   {
      return "[数值是"+rank+" "+"花色是"+suit+"]";
   }

}
class Box{
   private static final String[] suits={"♥","♠","♣","♦"};

   public static List<Card> BuyCard()
   {    List<Card> desk=new ArrayList<>();
      //我们接下来想用两层循环做到每一个花色生成13张牌
       for(int i=0;i<4;i++)//外层循环表示花色,i是可以从0下标开始进行的,因为他这个下标的意义是去除数组里面的元素
       {
          for(int j=1;j<=13;j++)//内层循环循环每一种花色的数字
          {
               String suit=suits[i];
               int rank=j;
               Card card=new Card(rank,suit);
               desk.add(card);//设置属性,构造牌，并把排放到list里面
          }
       }
       return desk;
   }
   //下一个方法我们要进行洗牌,使用洗牌的这个方法的时候,我们要把List传递过去
才可以进行正式的洗牌
   public static void xipai(List<Card> desk)
   {  int len=desk.size();
      for(int i=len-1;i>0;i--)
      {
         Random random=new Random();
         int index=random.nextInt(i);
         swap(desk,index,i);
      }
   }
   public static void swap(List<Card> list,int index,int i)
   {
      Card temp=list.get(i);
      list.set(i,list.get(index));
      list.set(index,temp);
   }
}
     public static void main(String[] args) {
//下面是测试方法
        TestDemo demo=new TestDemo();
       List<Card> list=demo.BuyCards();
        demo.xipai(list);
        System.out.println(list);
    }

在下面我们还要实现揭牌和玩牌的操作

1)一共有三个人，每一个人要轮流揭5张牌，我们把每一个人所揭的牌都放到对应的一个List数组里面

2)我们在实现一个List<List<card>>来方便进行管理总共放的牌

3)拿到Box里面的牌，调用remove(0)方法即可，就可以移除张牌了，因为每一个人揭一张牌，就相当于删掉了一张牌，况且我们每一次进行揭牌的时候，都是拿的最上面的一张牌，也就是0下标的牌，每一个人轮流揭牌

   List<Card> list=Box.BuyCard();
     System.out.println("开始进行买牌");
     System.out.println("开始进行洗牌");
         Box.xipai(list);
     System.out.println("开始进行玩牌和揭牌");
     List<Card> hand1=new ArrayList<>();//第一个人揭的牌就放在这个list数组里面
     List<Card> hand2=new ArrayList<>();//第二个人揭的牌就放在这个list数组里面
     List<Card> hand3=new ArrayList<>();//第三个人揭的牌就放在这个list数组里面
     List<List<Card>> fatherList=new ArrayList<>();//一会揭牌的时候看看该轮到那个人进行揭牌了
     hand.add(hand1);
     hand.add(hand2);
     hand.add(hand3);
     for(int i=0;i<5;i++)//三个人论流揭牌5张
     {
        for(int j=0;j<3;j++)
        {
           Card card=list.remove(i);
           fatherList.get(j).add(card);
//或者我们应该这么写:hand.get(j).add(list.remove(0));
        }
     }
      System.out.println("第一个人的牌"+hand1);
      System.out.println("第二个人的牌"+hand2);
      System.out.println("第三个人的牌"+hand3);
      System.out.println("剩下的牌"+list);
   }
//上面的循环不可以写成这样
for(int i=0;i<3;i++){
for(int j=0;j<5;j++){
}
}
//这就表示每一个人一下子揭5张牌

 private static void swap(int randomData, int i, List<Card> list) {
        Card a=list.get(i);
        Card b=list.get(randomData);
        Card temp=a;
        a=b;
        b=temp;
    }
//上面的这种写法是错误的,这只是进行修改局部变量的值,只是进行修改了实参的值,相当于是list没变

练习题六:实现一个杨辉三角

1
1 2 1
1 3 3 1
1 4 6 4 1
arr1[i][j]=arr1[i-1][j-1]+arr1[i-1][j],我们可以把每一行看成一个List

这个杨辉三角就是一个普通的直角三角形

class Solution{

public List<List<Integer>> generate(int numrows){

}

先以数组的方式来进行计算arr1[i][j]=arr1[i][j-1]+arr1[i][j]

我们计算的下标都是按照0来进行计算的

 public static void main(String[] args) {
      Scanner scanner=new Scanner(System.in);
      int n= scanner.nextInt();
  List<List<Integer>> ret=new ArrayList<>();
  List<Integer> list1=new ArrayList<>();
  //1我们先进行处理第一行
      list1.add(1);
      ret.add(list1);//到这里面我们才处理完杨辉三角的第一行
      for(int i=1;i<n;i++)//现在外层循环用来处理每一行
      {
       //每一行的第一个数字都是1,所以下面处理的是每一行的第一个数字
         List<Integer> list=new ArrayList();
         list.add(1);
         List<Integer> prev=ret.get(i-1);
         for(int j=1;j<i;j++)
         {
            int num=prev.get(j)+prev.get(j-1);
            list.add(num);
         }
         //处理每一行的结尾
         list.add(1);
         ret.add(list);
      }
      System.out.println(ret);
   }

C语言版本的杨辉三角:

package com.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

class Solution {
    public static int[][] generate(int line) {
        int[][] array=new int[line][line];
        for(int i=0;i<line;i++){
            array[i][0]=1;
            array[i][i]=1;
        }
        for(int i=1;i<line;i++){
            for(int j=1;j<i;j++){
                array[i][j]=array[i-1][j-1]+array[i-1][j];
            }
        }
      return array;
    }

    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int line=scanner.nextInt();
        //在这里面先计算出杨辉三角的正常状态
        int[][] array=generate(line);
        for(int i=0;i<line;i++){
            //打印每一行的时候,先进行打印前面的空格
            for(int k=0;k<line-i-1;k++){
                System.out.print(" ");
            }
            for(int j=0;j<line;j++){
                if(array[i][j]!=0){
                    System.out.print(array[i][j]+" ");
                }else{
                    System.out.print(" ");
                }
            }
            //最后执行换行操作
            System.out.println();
        }

    }
}

如何实现对List集合进行去重？

1)自定义去重:我们在这里面使用两个数组

通过循环判断当前的元素是否存在多个，如果存在多个那么删除此重复项

注意这里面的contains方法默认比较的是地址，也就是看是否指向同一个对象，“使用 List的contains方法用于判断对象是否存在于列表中

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

public class HelloWorld {
    static class Student{
        public String username;
        public int age;
        public Student(String username, int age) {
            this.username = username;
            this.age = age;
        }

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

        @Override
        public boolean equals(Object obj) {
            Student o=(Student)obj;
            return (this.age==o.age)&&(this.username==o.username);
        }
    }
    public static void main(String[] args) {
      List<Student> list=new ArrayList<>();
      Student student1=new Student("李佳伟",10);
      Student student2=new Student("李嘉欣",11);
      Student student3=new Student("李嘉诚",12);
      Student student4=new Student("李佳伟",10);
      list.add(student1);
      list.add(student2);
      list.add(student3);
      list.add(student4);
      Iterator<Student> It=list.iterator();
      List<Student> newList=new ArrayList<>(list.size());
      while(It.hasNext())
      {
         Student student= It.next();
         if(!newList.contains(student)){//如果新集合中不存在,就进行添加
             newList.add(student);
         }
      }
        System.out.println(newList);
    }
}

2)使用HashSet来进行去重，但是元素的顺序发生了变化，所以可以使用LinkedHashSet来进行去重，注意我们在这里面需要重写hashcode和equals方法，否则会导致去重失败

import java.util.*;

public class HelloWorld {
    static class Student{
        public String username;
        public int age;
        public Student(String username, int age) {
            this.username = username;
            this.age = age;
        }

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

        @Override
        public int hashCode() {
            return Objects.hash(username, age);
        }

        @Override
        public boolean equals(Object obj) {
            Student o=(Student)obj;
            return (this.age==o.age)&&(this.username==o.username);
        }
    }
    public static void main(String[] args) {
        List<Student> list=new ArrayList<>();
        Student student1=new Student("李佳伟",10);
        Student student2=new Student("李嘉欣",11);
        Student student3=new Student("李嘉诚",12);
        Student student4=new Student("李佳伟",10);
        list.add(student1);
        list.add(student2);
        list.add(student3);
        list.add(student4);
        Iterator<Student> It=list.iterator();
        LinkedHashSet<Student> set=new LinkedHashSet<>();
        while(It.hasNext())
        {
            Student student= It.next();
            set.add(student);
        }
        System.out.println(set);
    }
}

3)看看首次出现的位置和最后出现的位置是否相同:

import java.util.*;

public class HelloWorld {
    static class Student{
        public String username;
        public int age;
        public Student(String username, int age) {
            this.username = username;
            this.age = age;
        }

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

        @Override
        public int hashCode() {
            return Objects.hash(username, age);
        }

        @Override
        public boolean equals(Object obj) {
            Student o=(Student)obj;
            return (this.age==o.age)&&(this.username==o.username);
        }
    }
    public static void main(String[] args) {
        List<Student> list=new ArrayList<>();
        Student student1=new Student("李佳伟",10);
        Student student2=new Student("李嘉欣",11);
        Student student3=new Student("李嘉诚",12);
        Student student4=new Student("李佳伟",10);
        list.add(student1);
        list.add(student2);
        list.add(student3);
        list.add(student4);
        Iterator<Student> It=list.iterator();
        while(It.hasNext())
        {
           Student student=It.next();
           if(list.indexOf(student)!=list.lastIndexOf(student)){
               It.remove();
           }
        }
        System.out.println(list);
    }
}

4)使用JAVA8的新特性Stream进行去重:

import java.util.*;
import java.util.stream.Collectors;

public class HelloWorld {
    static class Student{
        public String username;
        public int age;
        public Student(String username, int age) {
            this.username = username;
            this.age = age;
        }

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

        @Override
        public int hashCode() {
            return Objects.hash(username, age);
        }

        @Override
        public boolean equals(Object obj) {
            Student o=(Student)obj;
            return (this.age==o.age)&&(this.username==o.username);
        }
    }
    public static void main(String[] args) {
        List<Student> list=new ArrayList<>();
        Student student1=new Student("李佳伟",10);
        Student student2=new Student("李嘉欣",11);
        Student student3=new Student("李嘉诚",12);
        Student student4=new Student("李佳伟",10);
        list.add(student1);
        list.add(student2);
        list.add(student3);
        list.add(student4);
        list=list.stream().distinct().collect(Collectors.toList());
        System.out.println(list);

    }
}