JAVA小白编程练习500题2帖超详细!!!带答案!!!持续更新中~

阳光穿透心脏的1/2处 2021-09-08 22:16 244阅读 0赞

# JAVA小白编程题练习2 #

##### 可能有很多刚入门的小白不知道自己如何能快速提升编程技巧与熟练度 #####

##### 其实大佬进阶之路只有一个~ 那就是疯狂码代码!!!实践出真知!!! #####

##### 所以为了大家能够想练习的时候有素材,泡泡给大家整理了一些练习题 #####

本帖是2帖，如果觉得难，可以先从1帖开始练习哦~

### [练习帖1 点我点我][1] ###

##### 由于平时比较忙,所以我在不定时努力更新中,欢迎监督~ #####

### 练习题：实现二分法查找/折半查找 ###

注意：折半查找的前提：数据必须是有序的

package cn.cxy.exec;
    
    import java.util.Arrays;
    import java.util.Random;
    import java.util.Scanner;
    
    public class BinarySearch { 
       public static void main(String[] args) { 
          //从方法，获取一个乱序数组
          int[] a = suiJi();
          //对a数组排序
          Arrays.sort(a);//优化的快速排序
          System.out.println(Arrays.toString(a));
          while(true) { 
             System.out.print("查找的目标值：");
             int t = new Scanner(System.in).nextInt();
             //二分法查找，
             //从a数组中，查找t的位置
             int index = binarySearch(a, t);
             System.out.println(index);
          }
       }
    
       private static int[] suiJi() { 
          //随机产生5+ [0,6)范围整数n
          int n = 5+ new Random().nextInt(6);
          //新建int[]数组，长度n
          //再存到变量a
          int[] a = new int[n];
          //遍历数组，填入100内随机整数
          for (int i = 0; i < a.length; i++) { 
             a[i] = new Random().nextInt(100);
          }
          //返回数组a
          return a;
       }
    
       private static int binarySearch(int[] a, int t) { 
          /* * t = 36 * mid * [16, 21, 30, 36, 39, 70, 70, 92] * lo * hi * *) lo和hi关系 lo<=hi * *) 交叉就是找不到数据 * *) lo位置是插入点位置 * * *)定义三个下标值 * lo=0, hi=a.length-1 * mid 只定义先不赋值 * *)循环，当lo<=hi * *)计算中间下表存到 mid * *)如果a[mid]<t，lo定位到mid+1 * *)否则如果a[mid]>t，hi定义到mid-1 * *)否则，返回mid的值 * *)lo、hi交叉结束 * 返回 -(lo+1)，表示-(插入点+1) */
          int lo = 0;
          int hi = a.length-1;
          int mid;
          while(lo <= hi) { 
             mid = (lo+hi) / 2;
             if(a[mid] < t) { 
                lo = mid+1;
             } else if(a[mid] > t) { 
                hi = mid-1;
             } else { 
                return mid;
             }
          }
          //避免lo是0，加1后，再加负号
          return -(lo+1); // -(插入点+1)
       }
    }

### 练习题：二分法实现数据动态插入 ###

注意：折半查找的前提：数据必须是有序的

package cn.cxy.exec;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Random;
    import java.util.Scanner;
    
    public class BinaryInsert { 
    	public static void main(String[] args) { 
    		/* * 集合、泛型，都不支持基本类型 * 用基本类型的包装类 */
    		ArrayList<Integer> list = new ArrayList<>();
    		System.out.println("回车继续");
    		while(true) { 
    			new Scanner(System.in).nextLine();
    			int n = new Random().nextInt(100);
    			//二分法查找，在list中找n所在的位置
    			//找不到，返回 -(插入点+1)
    			int index = Collections.binarySearch(list, n);  
    			if(index < 0) { 
    				index = (-index)-1;
    			}
    			list.add(index, n);
    			System.out.println(list.toString());
    		}
    	}
    }

### 练习题 : 求数字阶乘(递归解法版) ###

需求:接收用户输入的数字,计算该数字的阶乘结果
    已知:负数不可以有阶乘,0的阶乘结果是1,
    5 ! = 5 x 4 x 3 x 2 x 1
    
    package cn.cxy.design;
    //需求:求用户输入数字的阶乘结果
    //f(int n)--用来求阶乘
    //规律：
    //f(n)= n*f(n-1)
    //f(5)= 5*4*3*2*1 = 5*f(4) 
    //f(4)= 4*3*2*1 = 4*f(3)
    //f(3)= 3*2*1 = 3*f(2)
    //f(2)= 2*1 = 2*f(1)
    //f(1)= 1
    //
    //5!=5*4*3*2*1=120
    //4!=4*3*2*1
    //3!=3*2*1
    //2!=2*1
    //1!=1
    
    public class TestRecursion { 
    	public static void main(String[] args) { 
    		int result = f(15);//调用f()用来求阶乘
    		System.out.println(result);
    	}
    	/**递归的两要素 1.总结规律 2.最简问题*/
    	public static int f(int n) { 
    		if(n == 1) { //最简问题
    			return 1;
    		}else { //其他情况 n*f(n-1)
    			//递归:再方法内部自己调用自己
    			return n*f(n-1);
    		}
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70]

### 练习题 : 递归求目录总大小 ###

需求:递归求目录的总大小 D:\\ready,步骤分析如下:  
1.列出文件夹中的所有资源–listFiles()–>File\[\]  
2.判断,当前资源是文件还是文件夹–文件夹大小为0,文件大小需要累加  
–是文件,求文件的字节量大小length(),累加就行  
–是文件夹,继续列出文件夹下的所有资源–listFiles()–>File\[\]  
–判断,是文件,求文件的字节量大小length(),累加就行  
–判断,是文件夹,再一次列出文件夹下的所有资源  
–…重复操作  
也就是说,规律就是:只要是文件夹,就需要重复步骤1 2

package cn.cxy.file;
    
    import java.io.File;
    
    /**本类用来递归求目录总大小*/
    public class FileSumRecursion { 
    	public static void main(String[] args) { 
    		//1.指定要求哪个目录的总大小
    		/**注意:此处指定的目录必须是真实存在的 * 如果传一个不存在的文件夹会报错,如果是传了一个空文件夹,大小为0*/
    		File file = new File("D:\\ready");
    		//2.调用size()求目录大小
    		long total = size(file);
    		//3.接收结果并打印
    		System.out.println("文件夹的总大小为:"+total);
    	}
    
    	private static long size(File file) { 
    		//1.列出文件夹中的所有资源--listFiles()-->File[]
    		File[] fs = file.listFiles();
    		
    		//2.遍历数组,获取每file对象
    		//2.1定义变量,记录总和
    		long sum = 0;
    		for(int i = 0;i < fs.length ; i++) { 
    			//2.2通过下标操作当前遍历到的资源
    			File f = fs[i];
    			//2.3判断,当前资源是文件还是文件夹--文件夹大小为0,文件大小需要累加
    			if(f.isFile()) { 
    				//--是文件,求文件的字节量大小length(),累加就行
    				sum += f.length();//相当于:sum = sum + f.length();
    			}else if(f.isDirectory()) { 
    				//--是文件夹,继续列出文件夹下的所有资源,1 2步骤--listFiles()-->File[]
    				/**方法的递归,递归现象,就是在方法的内部调用方法自身*/
    				sum += size(f);
    			}
    		}
    		return sum;//把sum记录的值返回调用位置
    	}
    }

### 练习题 : 递归删除文件夹 ###

需求:递归删除文件夹 D:\\ready\\a  
1.列出文件夹下的所有资源listFiles()  
2.判断,当前资源是文件还是文件夹  
–判断,是文件,直接删除delete()  
–判断,是文件夹,继续重复操作1 2  
具体思路可以分为这么几步:  
1.首先,我们需要指定一个根目录作为要删除的对象  
2.列出文件夹下的所有资源listFiles(),并进行遍历  
3.判断当前的资源,如果是文件,直接删除;如果是文件夹,则执行步骤2  
4.将文件夹中的内容删除完毕后,删除文件夹本身

package cn.tedu.file;
    
    import java.io.File;
    
    /**本类用于递归删除目录*/
    public class TestFileDeleteRecursion { 
    	public static void main(String[] args) { 
    		//1.指定要删除的目录
    		/**为了更好的测试,注意指定的目录是已存在的目录,但是,千万不要删盘符!!!!*/
    		/*我们也有一些没有权限的文件夹,那个是无法访问且不能删除的哦*/
    		File file = new File("D:\\ready\\a");
    		//2.调用删除目录的方法
    		boolean result = del(file);
    		//3.打印删除的结果
    		System.out.println("删除的结果为:"+result);
    	}
    
    	public static boolean del(File file) { //完成的同学不是很多,抓紧时间写,写完截图发群里哈,这首歌结束我们继续
    		//1.列出文件夹下的所有资源
    		File[] fs = file.listFiles();
    		//2.循环遍历拿到的所有资源
    		for (int i = 0; i < fs.length; i++) { 
    			//2.1获取本次循环遍历到的file对象
    			File f = fs[i];
    			//3.判断,当前资源是文件还是文件夹
    			if(f.isFile()) { 
    				f.delete();//是文件,直接删除
    				System.out.println(file.getName()+"文件删除成功!");
    			}else if(f.isDirectory()) { 
    				//是文件夹,需要继续进行步骤1 2 ,出现了重复调用的情况
    				//递归,在方法的内部调用自己
    				del(f);
    			}
    		}
    		//位置:在for循环执行之外删除文件夹
    		file.delete();//空文件夹直接删除
    		System.out.println(file.getName()+"文件夹删除成功!");
    		return true;
    	}
    }

### 练习题 : 复制文件(字节流批量读取) ###

需求:接收用户目标文件的路径,复制目标文件到指定路径

import java.io.*;
    import java.util.Scanner;
    
    public class TestCopyFiles { 
        public static void main(String[] args) { 
            //1.提示并接收用户输入的要复制的源文件路径--复制啥
            System.out.println("请输入源文件路径:");
            String f = new Scanner(System.in).nextLine();
    
            //2.提示并接收用户输入的目标文件所在的位置--复制到哪
            System.out.println("请输入目标文件的路径:");
            String t = new Scanner(System.in).nextLine();
    
            //3.1根据源文件路径封装from文件对象
            File from = new File(f);
            //3.2根据目标文件路径封装to文件对象
            File to = new File(t);
            //3.3根据用户提供的路径完成文件的复制操作
            copy(from,to);
        }
    
        public static void copy(File from, File to) { 
            InputStream in = null;//定义在整个方法中都生效的字节输入流对象,注意是局部变量,需要初始化,对象的默认值是null
            OutputStream out = null;//定义在整个方法中都生效的字节输出流对象,注意是局部变量,需要初始化,对象的默认值是null
            try { 
                //1.读取from文件--操作文件的是字节输入流
                in = new BufferedInputStream(new FileInputStream(from));
                //2.写出到to文件--操作文件的是字节输出流
                out = new BufferedOutputStream(new FileOutputStream(to));
    
                //3.边读边写
                int b = 0;//定义变量b,记录读取到的数据
                /**需求:想要实现批量读取,使用的是read(byte[] b)重载的形式,可以按照数组的方式来读 */
                /**可以自定义数组,长度建议与源码保持一致,8*1024 = 8192*/
                byte[] bs = new byte[8*1024];
                while( (b=in.read(bs)) != -1 ) { //只有没有数据时,才返回-1,跳出循环,读写结束
                    out.write(bs);//将读到的数据写出到文件
                }
                System.out.println("恭喜您!文件复制成功!");
            } catch (IOException e) { 
                System.out.println("很抱歉!文件复制失败!");
                e.printStackTrace();//打印错误信息
            }finally { 
                //释放资源
                try { 
                    out.close();
                } catch (IOException e) { 
                    e.printStackTrace();
                }
                try { 
                    in.close();
                } catch (IOException e) { 
                    e.printStackTrace();
                }
            }
        }
    }

### 练习题 : 逆序遍历List集合 ###

手写一个程序，完成List集合对象的逆序遍历

package cn.cxy.exec;
    
    import java.lang.reflect.Array;
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    import java.util.ListIterator;
    
    /**本类用于进一步测试List接口*/
    public class TestList { 
        public static void main(String[] args) { 
            //1.创建List接口的多态对象
            List<String> list = new ArrayList<>();
            //2.向创建好list集合添加元素
            list.add("喜羊羊");
            list.add("美羊羊");
            list.add("懒羊羊");
            list.add("沸羊羊");
            list.add("小肥羊");
            list.add("肥羊卷");
            System.out.println(list);
            System.out.println("listIterator的逆序遍历：");
            ListIterator<String> it3 = list.listIterator();
            while(it3.hasNext()){ //判断是否有下一个元素可迭代
                System.out.println(it3.next());//打印当前迭代到的元素
                if(!it3.hasNext()){ //直到迭代器没有下一个元素可迭代--到最后了
                    System.out.println("开始逆序迭代：");
                    while (it3.hasPrevious()){ //判断是否有上一个元素可迭代
                        System.out.println(it3.previous());//打印获取到的上一个元素
                    }
                   break;//终止循环，不然会一直从头到尾，再从尾到头迭代
                }
            }
        }
    
    }

### 练习题 : 回文问题 ###

需求,如果一个用户输入的数据,从前到后或者从后到前读到的内容都是一样的,我们就称这种数据为"回文",比如123321 或者 12321 或者上海自来水来自海上等等

import java.util.Scanner;
    
    public class TestNumber { 
        public static void main(String[] args) { 
            System.out.println("请输入一个字符串:");
            String s = new Scanner(System.in).nextLine();
    
            if(!stringJudge(s)){ 
                System.out.println(s + "不是回文字符串");
            }else{ 
                System.out.println(s + "是回文字符串");
            }
            //调用第二个方法解决
            stringJudge2(s);
        }
    
        //判断字符串是否回文
        private static boolean stringJudge(String str) { 
            for (int i = 0; i < str.length() - i - 1; i++){ 
                if(str.charAt(i) == str.charAt(str.length() - i - 1)){ 
                    continue;
                }else{ 
                    return false;
                }
            }
    
            return true;
        }
        //判断字符串是否回文2
        private static void stringJudge2(String s) { 
            //方法2:将字符串反转比较
            String s2 = new StringBuffer(s).reverse().toString();
            if(s.compareTo(s2) == 0){ 
                System.out.println(s + "是回文字符串");
            }else{ 
                System.out.println(s + "不是回文字符串");
            }
        }
    }

### 练习题 : 手写数组列表 ###

手写一个数组列表，实现基本的数据操作功能

##### 数组列表类： #####

package cn.cxy.exec;
    
    import java.util.Arrays;
    
    public class ShuZuLieBiao<T> { 
    	T[] a;
    	int index;
    	public ShuZuLieBiao() { 
    		this(10);
    	}
    	public ShuZuLieBiao(int length) { 
    		a = (T[]) new Object[length];
    	}
    	public void add(T t) { 
    		//确认容量
    		queRenRongLiang();
    		a[index] = t;
    		index++;
    	}
    	private void queRenRongLiang() { 
    		//还有位置
    		if(index<a.length) { 
    			return;
    		}
    		//容量增长1.5倍
    		//防止初始长度是0，再加两个位置
    		int n = a.length + a.length/2 + 2;
    		a = Arrays.copyOf(a, n);
    	}
    	public T get(int i) { 
    		jianChaFanWei(i);
    		return a[i];
    	}
    	private void jianChaFanWei(int i) { 
    		//检查下标范围
    		if(i<0 || i>=index) { 
    			//抛出一个异常，表示这里出错
    			throw new IndexOutOfBoundsException(
    					"下标："+i);
    		}
    	}
    	public int size() { 
    		return index;
    	}
    	public T remove(int i) { 
    		jianChaFanWei(i);//检查范围
    		T t = a[i];//取出i位置的值
    		/* [i+1, index) 范围的值，向前复制1位 * i * [1,2,4,5,6,-,-,-,-,-,-] * | * index */
    		System.arraycopy(a, i+1, a, i, index-i-1); 
    		a[index-1] = null;
    		index--;
    		return t; //返回被移除的值
    	}
    }

##### 测试类： #####

package cn.cxy.exec;
    public class TestSZLB { 
    	public static void main(String[] args) { 
    		//泛型，不支持基本类型
    		ShuZuLieBiao<String> lb = new ShuZuLieBiao<>();
    		lb.add("aaa");
    		lb.add("vvv");
    		lb.add("ggg");
    		lb.add("rrr");
    		lb.add("qqq");
    		lb.add("uuu");
    		lb.add("aaa");
    		System.out.println(lb.size());
    		System.out.println(lb.get(0));
    		System.out.println(lb.get(lb.size()-1));
    		System.out.println(lb.remove(4));
    		for(int i=0;i<lb.size();i++) { 
    			System.out.println(lb.get(i));
    		}
    	}
    }

[1]: https://chengxiaoyu-paopao.blog.csdn.net/article/details/116569562
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70]: /images/20210827/188b40bfa9a1426fa0920b41542d5c14.png