Java练习500题持续更新~
2024-04-24 07:52:43
文章目录
- 1 10000以内的质数（素数）输出
- 1.1 10000以内质数输出的算法优化一
- 1.2 10000以内质数输出的算法优化二
- 2 鸡兔同笼共35只，脚94只，问分别多少只鸡兔
- 3 证明多态是运行时行为
- 4 单例饿汉式
- 4.1 线程安全的单例懒汉式
- 5 静态代理
- 5.1 动态代理（反射的应用）
- 6 斐波那契数列
- 7 Comparable自然排序
- 7.1 Comparator定制排序
- 8 子类重写的方法异常不大于父类的
- 9 算法之快速排序
1 10000以内的质数（素数）输出
/*
10000以内的质数（素数）输出 只能被1和它本身整除。--->从2开始到这个数-1结束为止都不能被这个数整除。
最小的质数是2*/
public class PrimeNumberTest {public static void main(String[] args) {boolean isFlag = true;//内存空间加载的变量少long start = System.currentTimeMillis();for (int i = 2;i<=10000;i++){//遍历10000以内的自然数//boolean isFlag = true;for (int j=2;j<i;j++){if(i % j==0){isFlag = false;}}if (isFlag == true)System.out.println(i);//重置isFlagisFlag = true;}long end = System.currentTimeMillis();System.out.println("用时："+(end-start));//84}
}
1.1 10000以内质数输出的算法优化一
/*
O(n) 与 O(n-1) 与 O(2n) 与 O(n/2)的时间复杂度都是O(n)级别，在一个量级上的*/
public class PrimeNumberTest1 {public static void main(String[] args) {//标识i是否被j除尽，一旦除尽，修改其值boolean isFlag = true;//内存空间加载的变量少long start = System.currentTimeMillis();for (int i = 2;i<=10000;i++){//遍历10000以内的自然数//boolean isFlag = true;for (int j=2;j<i;j++){ //j:被i去除if(i % j==0){ //i被j除尽isFlag = false;break;//优化一:一旦发现被除尽的j 后边的j就不除了 此优化只对非质数有效}}if (isFlag == true) {System.out.println(i);}//重置isFlagisFlag = true;}long end = System.currentTimeMillis();System.out.println("用时："+(end-start));//16}
}
1.2 10000以内质数输出的算法优化二
O(n) 与 O(n-1) 与 O(2n) 与 O(n/2)的时间复杂度都是O(n)级别，在一个量级上的*/
public class PrimeNumberTest2 {public static void main(String[] args) {//标识i是否被j除尽，一旦除尽，修改其值boolean isFlag = true;//内存空间加载的变量少int count = 0;//记录质数的个数long start = System.currentTimeMillis();for (int i = 2;i<=10000;i++){//遍历10000以内的自然数//boolean isFlag = true;//优化二：i开方 因为除不尽前面的数，后面的也就除不尽 临界值是平方根 此优化对质数有效（对非质数也有效只不过下面的break使得非质数到不了这一步）for (int j=2;j<=Math.sqrt(i);j++){ //j:被i去除if(i % j==0){ //i被j除尽isFlag = false;break;//优化一:一旦发现被除尽的j 后边的j就不除了 此优化只对非质数有效}}if (isFlag == true) {//System.out.println(i);//输出语句拖慢了程序时间count++;}//重置isFlagisFlag = true;}long end = System.currentTimeMillis();System.out.println("质数个数"+count);System.out.println("用时："+(end-start));//2}
}
2 鸡兔同笼共35只，脚94只，问分别多少只鸡兔
一共y只脚，定义脚为foot，则chicken*2+rabbit*4 ==y*/
public class Demo {public static void main(String[] args) {//鸡兔同笼，鸡兔一共35只，笼子里脚一共94只，请问分别有多少只兔子和多少只鸡？int foot = 94;//笼子里一共94只脚int sum = 35;//鸡兔一共35只for (int chicken = 1; chicken <= foot / 2; chicken++) {//鸡的数量int rabbit = sum - chicken;//兔子的数量if(rabbit * 4 + chicken * 2 == foot){System.out.println("兔子的只数为" + rabbit);System.out.println("鸡的只数为 " + chicken);} }}
}
3 证明多态是运行时行为
class Animal {protected void eat() {System.out.println("animal eat food");}
}
class Cat extends Animal {protected void eat() {System.out.println("cat eat fish");}
}
class Dog extends Animal {public void eat() { System.out.println("Dog eat bone"); }
}
class Sheep extends Animal {public void eat() { System.out.println("Sheep eat grass"); }
}public class InterviewTest {public static Animal getInstance(int key) {switch (key) {case 0:return new Cat ();case 1:return new Dog ();default:return new Sheep ();}}public static void main(String[] args) {int key = new Random().nextInt(3);System.out.println(key);Animal animal = getInstance(key);animal.eat();}
}
4 单例饿汉式
public class SingletonTest {
//此为单例饿汉式public static void main(String[] args) {Singleton instance1 = Singleton.getInstance();Singleton instance2 = Singleton.getInstance();System.out.println(instance2 == instance1);}
}
class Singleton {//1 私有化构造器private Singleton() {}//2 内部创建类的对象//5 (静态方法只能调静态的结构) 所以创建的对象也得是静态的private static Singleton instance = new Singleton();//3 提供公共的供外界调用的方法//4 把此方法声明为静态的(然后instance报错言外之意创建了对象才能在堆空间加载它)public static Singleton getInstance() {return instance;}
}
4.1 线程安全的单例懒汉式
public class SingletonTest1 {//单例线程安全的懒汉式public static void main(String[] args) {Single instance1 = Single.getInstance();Single instance2 = Single.getInstance();System.out.println(instance1 == instance2);}
}
class Single {private Single() {}//private static volatile Single instance = null;private static Single instance = null;public static Single getInstance() {if (instance == null) {synchronized (Single.class) {if (instance == null) {instance = new Single();}}}return instance;}
}
5 静态代理
//静态代理:代理类和被代理类在编译期间就确定下来了
interface ClothFactory{void produceCloth();
}
//代理类
class ProxyClothFactory implements ClothFactory{private ClothFactory factory;//用被代理类对象进行实例化public ProxyClothFactory(ClothFactory factory){this.factory = factory;}@Overridepublic void produceCloth() {System.out.println("代理工厂做一些准备工作");factory.produceCloth();System.out.println("代理工程做收尾工作");}
}
//被代理类
class NikeClothFactory implements ClothFactory{@Overridepublic void produceCloth() {System.out.println("Nike工厂生产一批运动服");}
}
public class StaticProxyTest {public static void main(String[] args) {ClothFactory nike = new NikeClothFactory();//创建代理类的对象ClothFactory proxyClothFactory = new ProxyClothFactory(nike);proxyClothFactory.produceCloth();}
}
5.1 动态代理（反射的应用）
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
interface ClothFactory{void produceCloth();
}
class NikeClothFactory implements ClothFactory{@Overridepublic void produceCloth() {System.out.println("nike工厂生产衣服");}
}
//反射的应用:动态代理举例
interface Human{String getBelief();void eat(String food);
}
//第1步
//被代理类
class SuperMan implements Human{@Overridepublic String getBelief() {return "I believe I can fly";}@Overridepublic void eat(String food) {System.out.println("我喜欢吃"+food);}
}
//问题一：如何根据加载到内存中的被代理类，动态地创建一个代理类及其对象
//问题二：当通过代理类的对象调用方法时，如何动态地去调用被代理类中的同名方法。
class ProxyFactory{//调用此方法返回一个代理类的对象public static Object getProxyInstance(Object obj){ //obj:被代理类的对象MyInvocationHandler handler = new MyInvocationHandler();handler.bind(obj);//第4.2步return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), handler);//第2步}
}
class MyInvocationHandler implements InvocationHandler{//第3步private Object obj;//需要使用被代理类的对象进行赋值 //第4.1步public void bind(Object obj){this.obj = obj;}//当我们通过代理类的对象调用方法a时，就会自动的调用如下的方法：invoke()//将被代理类要执行的方法a的功能就声明在invoke()中@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {//method:即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法//obj:被代理类的对象Object returnValue = method.invoke(obj, args);//第4步//上述方法的返回值就作为当前类中的invoke()的返回值。return returnValue;//第4.3步}
}
public class ProxyTest {public static void main(String[] args) {SuperMan superMan = new SuperMan();//proxyInstance:代理类的对象Human proxyInstance =(Human) ProxyFactory.getProxyInstance(superMan);//像接口的匿名实现类 再强转 //第5步String belief = proxyInstance.getBelief();//此方法会自动地调上面invoke()，invoke()中的method就是getBelief()System.out.println(belief);proxyInstance.eat("大众炒菜");//此方法会自动地调上面invoke()，invoke()中的参数method就是eat()，参数args就是"大众炒菜"，参数obj就是superManSystem.out.println("****************************************");NikeClothFactory nikeClothFactory = new NikeClothFactory();ClothFactory proxyInstance1 = (ClothFactory) ProxyFactory.getProxyInstance(nikeClothFactory);proxyInstance1.produceCloth();}//总结：编译时没有一个类叫代理类即代理类没有显式的定义，而是在运行时根据传过来的被代理类对象是谁，能动态地帮你创建代理类，体现了反射的动态性//动态代理相比静态代理的优点：抽象角色中（接口）声明的所有方法都被转移到调用处理器一个集中的方法中处理，这样，我们可以更加灵活和统一的处理众多的方法。
}
6 斐波那契数列
import java.util.Scanner;
//已知斐波那契数列的前几个数为0，1，1，2，3，5...从第三项开始每一项等于前两项的和。请接收用户输入的整数n输出此数列的前n项
public class Faibonacci {public static void main(String[] args) {System.out.println("请输入您要测试的项数:");int n = new Scanner(System.in).nextInt();//判断n是否是不正常的范围if(n<1){System.out.println("输入数据有误！！！");}//n==1if(n==1){System.out.println(0);}//n==2if(n==2){System.out.println(0+"\t"+1); }//n==3if(n==3){System.out.println(0+"\t"+1+"\t"+1); }//拼接前n项if(n>3){System.out.print(0+"\t"+1+"\t"+1+"\t"); }//循环输出后面的数据int f1=1;int f2=1;int next=0;for(int i=4;i<=n;i++){next=f1+f2;f1=f2;f2=next;System.out.print(next+"\t");}}
}
7 Comparable自然排序
import org.junit.Test;
import java.util.Arrays;
public class ComparableTest {//自然排序对应的接口是Comparable对应的抽象方法compareTo(Object obj)//定制排序对应的接口是Comparator对应的抽象方法compare(Object obj1,Object obj2)@Testpublic void test1(){Product[]arr = new Product[5];arr[0] = new Product("Huawei", 6299);arr[1] = new Product("Xiaomi", 4999);arr[2] = new Product("Vivo", 5999);arr[3] = new Product("Iphone", 9999);arr[4] = new Product("Honor", 6299);Arrays.sort(arr);for (int i = 0; i < arr.length; i++) {System.out.println(arr[i]);}}
}
class Product implements Comparable { //商品类private String name;//商品名称private double price;//价格public Product(String name, double price) {this.name = name;this.price = price;}public Product() {}public String getName() {return name;}public void setName(String name) {this.name = name;}public double getPrice() {return price;}public void setPrice(double price) {this.price = price;}@Overridepublic String toString() {return "Product{" +"name='" + name + '\'' +", price=" + price +'}';}@Override//自然排序public int compareTo(Object o) {if (o ==this){return 0;}if (o instanceof Product){Product p = (Product) o;int value = Double.compare(this.price,p.price);if (value !=0){return value;}return -this.name.compareTo(p.name);//加负号顺序相反}throw new RuntimeException("数据类型不匹配");}
}
7.1 Comparator定制排序
import org.junit.Test;
import java.util.Arrays;
import java.util.Comparator;
public class ComparatorTest {//自然排序对应的接口是Comparable对应的抽象方法compareTo(Object obj)//定制排序对应的接口是Comparator对应的抽象方法compare(Object obj1,Object obj2)@Testpublic void test1(){Product[]arr = new Product[5];arr[0] = new Product("Huawei", 6299);arr[1] = new Product("Xiaomi", 4999);arr[2] = new Product("Vivo", 5999);arr[3] = new Product("Iphone", 9999);arr[4] = new Product("Honor", 6299);//定制排序 创建一个实现了Comparator接口的实现类的对象Comparator comparator = new Comparator() {@Overridepublic int compare(Object o1, Object o2) {if (o1 instanceof Product && o2 instanceof Product){Product p1 = (Product) o1;Product p2 = (Product) o2;return Double.compare(p1.getPrice(), p2.getPrice());}throw new RuntimeException("类型不匹配");}};Comparator comparator1 = new Comparator() {@Overridepublic int compare(Object o1, Object o2) {if (o1 instanceof Product && o2 instanceof Product){Product p1 = (Product) o1;Product p2 = (Product) o2;return p1.getName().compareTo(p2.getName());}throw new RuntimeException("类型不匹配");}};Arrays.sort(arr, comparator1);for (int i = 0; i < arr.length; i++) {System.out.println(arr[i]);}}
}
class Product { //商品类private String name;//商品名称private double price;//价格public Product(String name, double price) {this.name = name;this.price = price;}public Product() {}public String getName() {return name;}public void setName(String name) {this.name = name;}public double getPrice() {return price;}public void setPrice(double price) {this.price = price;}@Overridepublic String toString() {return "Product{" +"name='" + name + '\'' +", price=" + price +'}';}
}
8 子类重写的方法异常不大于父类的
import java.io.FileNotFoundException;
import java.io.IOException;
public class OverrideTest {//子类重写的方法的异常类型不能大于父类的被重写的方法的//子类重写方法的返回值类型不得大于父类的被重写的方法的public static void main(String[] args) {Father f = new Son();try {f.method1();}catch (IOException e){//编译看左边，真正运行时调的是子类的方法，子类方法如果抛的异常类型就进不去catch，要想进得去旧的不大于catch内的异常类型。（多态）e.printStackTrace();}Number n = f.method3();//（多态）实际执行时返回的是Number的子类的对象}
}
class Father{public void method1() throws IOException{}public void method2(){}public Number method3(){return null;}
}
class Son extends Father{public void method1()throws FileNotFoundException{}// public void method2()throws FileNotFoundException{}//父类没有抛编译时异常子类更不能抛，此方法要有编译时异常只能try catchpublic Integer method3(){return null;}
}
9 算法之快速排序
Java练习500题持续更新~相关推荐
- 《LeetCode 热题 HOT 100》Java答案汇总版---持续更新中
<LeetCode 热题 HOT 100>Java答案汇总版-持续更新中 个人认为<LeetCode 热题 HOT 100>中的题目特别适合算法新手进行一个入门的刷题,而且作者 ...
- Java自学视频整理(持续更新中...)
1.Java基础视频 <张孝祥JAVA视频教程>完整版[RMVB](东西网) 历经5年锤炼(史上最适合初学者入门的Java基础视频)(传智播客) 张孝祥2010年贺岁视频:Java高新技术 ...
- English：英语六级听力及其真题(持续更新！)
English:英语六级听力及其真题(持续更新!) 目录 英语六级听力及其真题(持续更新!) 英语六级听力及其真题(持续更新!) 地址:http://www.kekenet.com/cet6/1642 ...
- 【剑指offer】java版题解（持续更新）
本文为刷[剑指]备战校招的过程,持续更新 备战虽晚但卷,共勉! 目录,按刷题时间排序 斐波那契数列 用两个栈实现队列 二维数组中的查找 包含min函数的栈 从尾到头打印链表 反转链表 复杂链表的复制 ...
- JDK 7-JDK 21：Oracle Java SE 支持路线图/Oracle Java SE Support Roadmap 持续更新
文章目录 前言 一.Oracle Java SE 产品版本 二.Java SE 8 的公共更新结束 三.参考文档 总结 前言 几十年来,Java 生态系统已经成功地经历了这个过程,经历了十次主要的平台 ...
- java高级面试视频,持续更新~
Java高级工程师面试:Java中反射机制的理解!反射机制的使用原理深入理解Java中的反射反射的概念反射的原理反射的主要用途反射的运用获得Class对象判断是否是某个类的实例创建实例获取方法获取构造 ...
- 2020年 近期出去面试Java的总结（持续更新）
近期出去面试Java的总结 一.Java基础 1.Java的类加载顺序 对于有继承关系的加载顺序 2.Java的创建对象的几种方式 1.使用new关键字 2.使用反射机制 1)使用Class类的new ...
- 2023 亲自经历面试的初中级java面试题（持续更新）
面试题 基础题 集合 说一下list,set,map的区别. hashMap key是自己定义的类,有没复写过hashcode或者equals这些方法 ? 线程安全问题 List ArrayList ...
- PHP 2021面试题，一般所遇到的问题与答案，多达51题(持续更新)
GET 与 POST 的区别 **显示有区别** get方法是将字符串拼接在地址栏后面可以看见 而post方法看不见**传递的大小有区别** 具体大小和浏览器有关系,ie浏览器是2k其他浏览器的最大值 ...
最新文章
- 网路游侠：日志审计系统与SOC的区别
- 【复杂网络】复杂网络多种算法及工具应用集合
- python私人兼职_python能做什么副业#下班后有哪些兼职副业
- 混合多云架构_使用混合多云每个人都应避免的3个陷阱（第2部分）
- 使用JAX-RS（Jersey）的HTTP状态错误消息响应中的自定义原因短语
- python - 环境搭建
- 【译】如何写出一份优秀的软件设计文档
- DJ设备市场现状及未来发展趋势
- SecureCRT绿色版的下载和安装
- Linux 程序 动态库 静态库依赖关系
- 开源数据库连接池的使用
- Openbravo ERP介绍（三）
- 【网络流24题23】火星探险问题
- linux添加jetdirect协议,Linux系统中如何打印
- oracle表数据误删恢复，表误删恢复
- 【Windows】关于Windows Powershell找不到打不开修复方法
- 蓝牙耳机录音进行讯飞语音识别
- Android三种姿势带你玩转360度全景图功能
- Monkey King【大根堆】
- 计算机专业证书难度,计算机专业应该考这些证书！