自己写过的一点java程序小练习

最新推荐文章于 2024-08-30 18:40:43 发布
最新推荐文章于 2024-08-30 18:40:43 发布
阅读量44 收藏
点赞数 1
文章标签： java python 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/haiweiyi_zwbs/article/details/134407859
版权

1.链表 

package javakaoyan;

public class LinkList<T> {

	/**
	 * @param args//链表的实现
	 */
	//结点定义
	private class Node{
		//数据
		T item;
		//指向下一个结点
		Node next;
		//构造器
		public Node(T item,Node next){
			this.item=item;
			this.next=next;
		}
		public Node(T item){
			this.item=item;
		}
	}
	
	private Node head;//头结点
	private Node tail;//尾结点
	private int size;//结点个数
	
	//链表定义
	public LinkList(){
		this.head=new Node(null,null);
		size=0;
	}
	
	//查找指定位置的链表结点
	public Node get(int index){
		if(index<0||index>=this.size){
			return null;
		}else{
			Node temp=this.head;
			for(int i=1;i<=index;i++){
				temp=temp.next;
			}
			return temp;
		}
	}
	
	//链表插入数据
	public void add(T data)
	{
		Node temp =new Node(data);
		//链表为空
		if(this.size==0){
			head=temp;
			tail=head;
		}
		else{
			Node last=tail;
			last.next=temp;
			this.tail=temp;
		}
		this.size++;
	}
	
	//在链表的第i个位置插入一个值为t数据
	public void insert(int index,T data) throws Exception{
		if(index<0||index>this.size){
			throw new Exception("插入超出范围");
		}
		else{
			Node newNode=new Node(data);
			//在头结点插入元素
			if(index==0){
				if(this.size>0){
					Node temp=head;
					newNode.next=temp;
				}
				head=newNode;
			}
			//尾结点插入
			else if(index==this.size){
				Node temp=tail;
				temp.next=newNode;
				this.tail=newNode;
			}else{
				//在中间插入元素
				Node preNode=get(index-1);
				Node nextNode=preNode.next;
				newNode.next=nextNode;
				preNode.next=newNode;
			}
		}
		this.size++;
		if(size==1){
			tail=head;
		}
	}
	
	
	//删除指定位置数据
	public void del(int index) throws Exception{
		if(index<0||index>this.size){
			throw new Exception("删除超出范围");
		}	else{
			//删除头结点
			if(index==0){
				Node temp=this.head.next;
				this.head=temp;
			}
			//删除尾结点
			else if(index==this.size-1){
				Node preNode=get(index-1);
				this.tail=preNode;
				preNode.next=null;
				
			}else{
				//删除中间结点
				Node preNode=get(index-1);
				Node nextNode=preNode.next.next;
				preNode.next=nextNode;
				
			}
		}
		this.size--;
	}
	
	//移除末尾元素，并返回对应数据
	public T remove() throws Exception{
		if(this.size==0){
			System.out.println("链表为空，无法移除");
			
		}
		//只有一个元素，移除后为空
		if(this.size==1){
			T data=this.head.item;
			this.head=null;
			this.tail=this.head;
			this.size--;
			return data;
		}else{
			Node preNode=get(this.size-2);
			T data=this.tail.item;
			preNode.next=null;
			this.tail=preNode;
			this.size--;
			return data;
		}
	}
	
	//删除特定元素的一个位置
	public boolean deleteData(T data){
		boolean flag=false;
		if(this.size==0){
			return flag;
		}else{
			Node curNode=this.head;
			//元素位于第一个结点
			if(curNode.item==data){
				Node nextNode=curNode.next;
				head=nextNode;
				flag=true;
				//当前只有一个结点
				if(this.size==1){
					tail=head;
				}
				this.size--;
			}else{
				while(curNode!=null){
					Node nextNode=curNode.next;
					if(nextNode!=null&&nextNode.item==data){
						//删除元素为尾结点
						if(nextNode.next==null){
							this.tail=curNode;
							curNode.next=null;
						}else{
							//删除结点为中间结点
							Node temp=curNode.next.next;
							curNode.next=temp;
						}
						flag=true;
						this.size--;
						break;
					}
					curNode=curNode.next;
				}
			}
		}
		return flag;
		
	}
	
	public void printLinklist(){
		if(this.size==0){
			System.out.println("链表为空");
			
		}
		else{
			Node temp=head;
			System.out.println("目前的链表，头结点"+head.item+"，尾结点"+tail.item+",整体:");
			while(temp!=null){
				System.out.println(temp.item+",");
				temp=temp.next;
			}
			System.out.println();
		}
	}
	
	
	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub

		LinkList linklist=new LinkList();
		linklist.add("2");
		linklist.del(0);
		linklist.printLinklist();
		linklist.insert(0, "a");
		System.out.println("删除的元素为："+linklist.remove());
		linklist.insert(0, "2");
		linklist.insert(1, "3");
		linklist.add("3");
		linklist.printLinklist();
		linklist.del(1);
		linklist.printLinklist();
		linklist.insert(1, "1");
		
		linklist.insert(0, "0");
		linklist.insert(2, "0");
		linklist.del(2);
		linklist.printLinklist();
		linklist.deleteData(3);
		linklist.printLinklist();
		
	}

}

2.线性表

package javakaoyan;

import java.util.Arrays;

public class xianxinbiao {

	/**
	 * @param args
	 * 线性表：代码表示：（用数组的方法）
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		xianxinbiao b=new xianxinbiao(10);

		b.insert(20);
		b.insert(20);
		b.insert(20);
		b.insert(20);
		
		b.insert(20);
		b.insert(20);
		b.insert(20);
		b.insert(20);
		
		b.insertS(3, 60);
		System.out.println(Arrays.toString(b.getItem()));
		
		
	}
	private Object[] listItem;//存储位置
	private int curlen;//长度
	private int maxSize;//最大容量
	//线性表初始化
	xianxinbiao(int maxSize){
		this.maxSize=maxSize;
		this.listItem=new Object[maxSize];
		this.curlen=0;
	}
	//顺序插入值
	public void insert(Object data){
		if(curlen==maxSize){//每次插入值后满容量
			System.out.println("线性表已满");
		}
		else{
			listItem[curlen]=data;
			curlen++;//加完后改变线性表长度
		}
		
	}
	public int getCurlen(){
		return this.curlen;
	}

	//顺序表指定位置插入
	public void insertS(int index,Object data){
		if(curlen==maxSize){System.out.println("线性表已满");}
		else{
			for(int i=curlen;i>index;i--){
				listItem[i]=listItem[i-1];
			}
			listItem[index]=data;
			curlen++;
		}
	}
	
	//删除指定位置元素
	public void deleteS(int index){
		//顺序表往前移，最后删掉一格
		for(int i=index;i<this.curlen;i++){
			this.listItem[i]=this.listItem[i+1];
		}
		this.curlen--;//删完后要改变顺序表长度
	}
	
	//删除所以元素
	public void deleteAll(){
		this.curlen=0;
	}
	//获取顺序表数据
	public Object[] getItem(){
		return this.listItem;
	}
	
	
	
	
	
}

 3.给定一个数值（可以带负号），计算从i到j的和，求最大值以及i和j
例如 -1 1 -5 66 -7 -3 -1 66 99 -138 -124  4

package zhenti;

public class zhenti202301 {

	/**
	 * @param args
	 * 1.给定一个数值（可以带负号），计算从i到j的和，求最大值以及i和j
例如 -1 1 -5 66 -7 -3 -1 66 99 -138 -124  4
求时间复杂度
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
        int[] a={-1, 1, -5, 66, -7, -3, -1, 66, 99, -138, -124, 4};
		//int[] a={-1, 1, 66,-11};
        int max=a[0]+a[1];
        int sum=0;
        int b=0,c=1;
        for(int i=0;i<a.length-1;i++){
          sum=a[i];
           for(int j=i+1;j<a.length;j++){
        	   sum=a[j]+sum;
        	   if(sum>max){
        		   max=sum;
        		   b=i;
        		   c=j;
        	   }
           }
           sum=0;
        	
        }
        System.out.println("该数组的从第"+b+"到"+c+"的总和最大，最大值:"+max);
        //时间复杂度：O(n²)
	}

}

4.递归题，给一个x，y，如果x能整除y，这确定y为x的最大公约数
如果x不能整除y，这用y和（x，y）的余数来继续执行，直到x能整除y

package zhenti;

import java.util.Scanner;

public class zhenti202302 {

	/**
	 * @param args
	 * 2.递归题，给一个x，y，如果x能整除y，这确定y为x的最大公约数
如果x不能整除y，这用y和（x，y）的余数来继续执行，直到x能整除y

	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		int x,y;
		System.out.println("请输入除数x和除数y:");
		Scanner scanner=new Scanner(System.in);
		x=scanner.nextInt();
		y=scanner.nextInt();
		System.out.println("除数的结果:"+digui(x,y));
		
	}
	static int digui(int x,int y){
		int temp;
		if(x%y==0){
			return y;
		}
		else{
			temp=x%y;
			return(digui(y,temp));
		}
		
	}

}

5.文件

package zhenti;

import java.io.*;

public class zhenti202304 {

	/**
	 * @param args
	 * 4.文件题，给一个大的定义和大量数据，如葡萄酒里的指标，然后用文件方法来判断
（1）这个葡萄酒里的数字对应的指标类型(数字小数：指标1， 数字整数：指标2  数字小数整数混合：指标3)，写到文件里去
（2）对于某个具体类型，取最大最小值
（4）如果文件确实，如何弥补
0.8 0.2 0.4  0.5  0.1 0.4 0.6  0.1
1   0.3 0.77 0.81 0.6 0.1 0.12 0.23
a   b   c    d    e   f   g    h
0.8 0.2 0.4  0.5  0.1 0.4 0.6  0.1
1   0.3 0.77 0.81 0.6 0.1 0.12 0.23
0.8 0.2 0.4  0.5  0.1 0.4 0.6  0.1
1   0.3 0.77 0.81 0.6 0.1 0.12 0.23
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
      double[][] str={{1,0.3,0.77,0.81,0.6,0.1,0.12,0.23},{0.1,0.3,0.77,0.81,0.6,0.1,0.12,0.23},
    		  {1,2,3,4,5,6,7,8}};
      System.out.println(str.length);
      File file=new File("F://game/zhenti202304.txt");
      try{
    	 
    	 FileWriter fo=new FileWriter(file);
    	 BufferedWriter fb=new BufferedWriter(fo);
    	  for(int i=0;i<str.length;i++){
        	  for(int j=0;j<str[0].length;j++){
        		fb.write(Double.toString(str[i][j])+" ");
        	  }
        	 fb.newLine();
          }
    	  for(int i=0;i<str.length;i++){
    		  int t=0;
              if(t<str[0].length&&str[i][t]>1){
            	  t++;
              }
        	 fb.write("第"+i+"行为:指标"+t);
        	 fb.newLine();

          }
    	  fb.close();
    	  fo.close(); 

      }
      catch(IOException e){
    	  System.out.println(e);
      }
      
      
    
      
		
		
	}

}

6.线程

package zhenti;

public class zhenti202305 {

	/**
	 * @param args
	 * 从ATM里取款，要求（1）可以多用户取款，但同一时间的一个用户只能被一个人取款
（2）如果取款小于用户的账户余额，则进入等待状态
（3）当用户的余额大于存款时，从等待状态中唤醒，然后继续操作。
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		bankThread b1=new bankThread("123456",100);
	    new bankgetMoney("甲",b1,800).start();
	    new bankgetMoney("乙",b1,1000).start();
	    new bankgetMoney("丙",b1,100).start();
		
	}

}
class bankThread {
	String name;
	double number;
	bankThread(String name,double number){
		this.name=name;
		this.number=number;
	}
	public synchronized void draw(double number1){
		if(number>=number1){
			System.out.println(Thread.currentThread().getName()+"取钱成功:"+number1);
			try{
				Thread.sleep(300);
			}catch(InterruptedException e){
				e.printStackTrace();
			}
			number=number-number1;
			System.out.println("余额"+number);
		}
		else{
			synchronized(Thread.currentThread()){
			try{
				Thread.currentThread().wait(1000);
			}catch(InterruptedException e){
				e.printStackTrace();
			}
			}
			System.out.println(Thread.currentThread().getName()+"取钱失败");
		}
	}
	
}
class bankgetMoney extends Thread{
	private bankThread bankThread;
	private double money;
	bankgetMoney(String name,bankThread bankThread,double money){
		super(name);
		this.bankThread=bankThread;
		this.money=money;
	}
	public void run(){
		bankThread.draw(money);
	}
}

haiweiyi_zwbs
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
06从零开始学Java之编写第一个Java程序HelloWorld
一一哥
03-14 3144
在之前的文章中，壹哥带大家搭建出了Java的开发环境，配置了JDK环境变量，并且我们也熟悉了dos命令行的操作。总之，在真正进行编写代码之前做了很多准备工作，我相信各位早就迫不及待的想要编写代码了。那么从这篇文章开始，壹哥就开始带各位真正地学习Java代码该怎么写。就问你激动不激动？Let's go！前戏已做完，精彩即开始全文大约【3000】字，不说废话，只讲可以让你学到技术、明白原理的纯干货！
【java实现100以内加减法口算练习程序】
m0_48960163的博客
06-06 1466
软件构造：100以内加减法口算练习程序界面设计
Java简单案例练习
weixin_50769390的博客
07-05 4631
java基础简单练习，基础加强
Java小练习
AWA124的博客
05-08 417
      （1）功能描述：为指定成绩加分，直到分数大于等于 60 为止，输出加分前和加分后的成绩，并统计加分的次       数。代码如下：public class HelloWorld { public static void main(String[] args) { // 变量保存成绩 int score = 53; ...
java小练习
再吃一个橘子
06-24 995
1.从键盘输入n个数，求这n个数中的最大数与最小数并输出，输出样例如下： import java.util.Scanner; public class Test { public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.println("请输入数组长度:"); int num = sc.nextInt(); System.out.println("请输..
学习Java的实例小练习
04-06
在这个"学习Java的实例小练习"中，我们可以看到两个文件——cxy和lfy，这很可能是两个不同的Java代码实例或者小型项目。 在编程时，注释是一种必不可少的工具，它有助于理解代码的功能和工作原理。好的注释可以使...
Java写的打地鼠小游戏
12-05
《Java实现的打地鼠小游戏详解》 打地鼠小游戏是一款深受玩家喜爱的经典休闲游戏，其简单的操作方式和快速反应的挑战性使得它在各种年龄段的用户中都有很高的普及度。本篇将深入探讨如何使用Java语言来实现这样一个...
Java 练习 Java学习资料
06-24
标签"java课程资源"进一步确认了这一点，暗示我们可能找到的是一个用于教学或自我提升的Java学习包。 这个名为"java-se-master"的压缩文件很可能包含了Java Standard Edition（Java SE）的相关内容，SE是Java的基础...
Password-Trunk:我今年夏天制作了一个小Java应用程序，以练习编码并学习如何使用JTable。
05-03
我今年夏天用Java设计的一个小软件可以练习我的编码并学习如何使用JTable。 我为父母设计了密码，这样他们就可以轻松存储密码。 用户输入网站/应用程序的名称，其登录名和密码。 应用程序将其存储在文件中。 这...
Java基础（6）- Java代码笔记3
最新发布
weixin_47062560的博客
08-30 454
数据类型[][] 数组名 = new 数据类型[m][n]数据类型 数组名[][] = new 数据类型[m][n]数据类型[] 数组名[] = new 数据类型[m][n]m：代表二维数组长度n：代表二维数组中每个一维数组的长度。
启动Application 报错：no mapping for GET /（已解决）
qq_3512323979的博客
08-26 5213
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
[C++规范] 访问类成员变量的方式：直接访问还是通过成员函数访问？
Loewen丶的小窝
08-26 5386
在面向对象编程（OOP）中，通过成员函数（如`ME_HardwareTypeEnum Type() const;` 和 `int Id() const;`）来访问类的私有或受保护成员（如`m_hardwareType` 和 `m_id`），而不是直接通过公共成员访问，是一种更好的做法。
操作系统原子操作
zzt_is_me的博客
08-28 3395
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
Spring WebFlux – CVE-2023-34034 – 撰写和概念验证
技术超强的网络安全平台
08-28 2135
Spring框架是一个广泛使用的基于Java的应用程序框架，为企业级Java应用的开发提供基础设施支持。是一个功能强大的身份验证和访问控制框架，也是保护基于 Spring 的应用程序的行业标准。它提供身份验证和授权，并且可以轻松扩展以满足自定义要求。Spring WebFlux是在 Spring 5 中引入的，作为传统框架的响应式编程替代方案。Spring WebFlux 的核心设计旨在处理异步、非阻塞和反应式编程范例。它提供了一种反应式编程模型，允许开发人员构建可扩展、响应迅速且具有弹性的应用程序。
基于jenkins部署maven项目
静水深流
08-26 2843
如上所示，构建后，我们处于项目的根目录之下，可以进行后续的操作，如启动target目录下的jar包、将jar包传输到需要部署的服务器上、打docker镜像bing上传等等，需要根据实际情况进行选择，而这些都可以在“Add post-build step”选项中进行选择。我们主要关注上述几个部分，在General部分，可以对项目进行一个简单的描述，源码管理部分，需要配置对应的源码url，如下图所示。如上所示，选择“构建一个maven项目”，如果没有改选项，则需要安装maven构建的插件，请参考之前的文章。
输入三个正整数，找出不大不小的值
laocooon的博客
08-30 456
/ 找出最大值，找出最小值，然后不是最大值也不是最小值的。// 2、输入三个正整数，找出不大不小的值。
死锁及其产生条件
秋夫人
08-26 1531
死锁是指两个或多个线程（或进程）互相等待对方释放资源，导致所有相关线程都无法继续执行的情况。这是并发编程中的一个常见问题，可能会导致系统部分或完全停止响应。
JVM 内存参数
iOS逆向与安全
08-29 773
它屏蔽了与具体操作系统平台相关的信息，使Java程序只需生成在Java虚拟机上运行的目标代码（字节码），就可以在各种平台上不加修改的运行。‌例如，‌可以将最小堆内存设置为2GB（‌-Xms2048m）‌，‌最大堆内存设置为4GB（‌-Xmx4096m）‌。如果初始化的高水位线设置过低，会频繁的触发Full GC，高水位线会被多次调整。一般来说，垃圾回收器都会有默认的对象晋升到老年代的年龄参数阈值，CMS默认是6，G1默认是15，不过这参数值也不是一成不变的，它会根据动态年龄判断规则来重新被赋值。
Java并发编程 进程与线程
m0_56369671的博客
08-28 816
操作系统中有一个组件叫做任务调度器，将 cpu 的时间片（windows下时间片最小约为 15 毫秒）分给不同的程序使用，只是由于 cpu 在线程间（时间片很短）的切换非常快，人类感觉是 同时运行的。但如果是四核 cpu，各个核心分别使用线程 1 执行计算 1，线程 2 执行计算 2，线程 3 执行计算 3，那么 3 个线程是并行的，花费时间只取决于最长的那个线程运行的时间，即 11ms 最后加上汇总时间只会花费 12ms 注：需要在多核 cpu 才能提高效率，单核仍然时是轮流执行。
Java编程练习：程序填空与知识点回顾
选择题中，反映Java程序并行机制特点的是B)多线性。 类的声明规则是重要的基础知识，如D) `public abstract class Car {/*...*/}`是正确的声明，而其他选项违反了Java的语法规则。 循环结构中，for和while都可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值