Java中如何实现结构体?如何对结构体进行排序?

***今天在做老师布置的编程题时,遇到了本题。感觉这道题如果用C++来解决的话,用结构体比较好吧!哈哈哈,可能还有其他的好方法,但我目前想到的是用结构体来解决比较合理。Java中有结构体吗?如果有,它是如何实现的呢?实例和解决方法见下。(前面是Java中有关结构体的一些知识点,后面是举一个实例和解决代码)***


C/C++里面的结构体在储存(同类型或不同类型的成组的)数据的时候很方便,但是在Java中没有Struct,但是我们可以用类来实现Struct的功能。然后创建类的对象数组,就可以像操作C/C++中的结构体那样,对其进行比较排序,读写值等等操作,还是很方便的。

其中,用类实现结构体并对其进行操作时,其实是有两种方式可选的:

方式一:

把要存储的数据设为私有变量,然后另写函数对其进行读写,set()和get()

public  class Test
{
    private int x;
    private int y;
    public int getX() {
        return x;
    }
    public void setX(int x) {
        this.x = x;
    }
    public int getY() {
        return y;
    }
    public void setY(int y) {
        this.y = y;
    }
}

方式二:

把要存储的数据设为public变量,在其他主函数类中直接访问修改。

class Supply implements Comparable<Supply>{
	int number;
	int max;
	int spend;
}

方式二虽然更简单,但是封装性不好,适合解决简单问题。总之,各有各的好处!

介绍完了用类实现结构体,下面就介绍一下如何对类实现的结构体的对象数组进行自定义排序。

定义一个(结构体)类实现Comparable接口,然后在类中重写compareTo()方法(自定义排序哦),最后用Arrays.sort()进行排序。

import java.util.*;  

class S implements Comparable<S>  
{  
    int x,y;  
    public S(int x ,int y) {
        this.x = x;
        this.y = y;
    }
    public int compareTo(S a)  
    {    
        if(this.x-a.x != 0)   
        return this.x-a.x;  //按x升序排序
        else return this.y-a.y;  //如果x相同,按y升序排序
    }  
}  
public class Test
{    
    public static void main(String args[])  
    {  
        Scanner in=new Scanner (System.in);  
        int n,i;  
        n=in.nextInt();
        S d[] = new S[10];  
        for(i=0; i<n; i++)  
        {  
            int k1 = in.nextInt();
            int k2 = in.nextInt();
            d[i] = new S(k1,k2);        
        }  
        Arrays.sort(d, 0, n); //排n个数,Arrays.sort(d)则默认排全部  
        for(i=0; i<n; i++)  
            System.out.println(d[i].x+" "+d[i].y); 
    }  
}

运行结果:

3
4 5
2 4
2 3
2 3
2 4
4 5


【问题描述】

有n个某种商品供应商,某地有m个商店,商店需要从供应商那里进货该商品,每个供应商的供应能力有上限,每个商店都有自己的商品需求量(need[i]:表示第i个商店的需求),每个供应商运送单位商品到商店需要一个运费。


【输入形式】

输入说明:第一行包含两个整数N,M

接下来N行包含三个整数,第一个数表示供应商编号,第二数表示供应能力上限,表示该供应商的供应量不能超过这个上限,第三个数表示运送单位商品到商店的运费。

接下来M行包含两个整数,第一个数表示商店编号,第二个数表示某种商品的需求量。


【输出形式】

输出说明:若可以满足所有商店需求,则输出格式如下:每行第一个数表示供应商编号,第二个数为商店编号,第三个数为供应量。

如:1 2 20

表示第1个供应商给第2个商店供应20个单位量的商品

按商店编号顺序,输出所有供应路径(最后一行无换行符)。

若不满足,输出-1(题目有毒,根据测试用例,应该是按照运费少的先供应,而且只用输出最少运费的供应方案即可)


【样例输入】

4 4

0 20 8

1 15 3

2 55 6

3 40 10

0 28

1 36

2 49

3 12


【样例输出】

1 0 15

2 0 13

2 1 36

2 2 6

0 2 20

3 2 23

3 3 12

解题代码见下:

package homework5;

import java.util.*;

class Supply implements Comparable<Supply>{
	int number;
	int max;
	int spend;
	public Supply(int n,int m,int s) {
		this.number=n;
		this.max=m;
		this.spend=s;
	}
	public int compareTo(Supply s) {
		return this.spend-s.spend;
	}
}

public class Main5 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Supply []s = new Supply[100];
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int m = sc.nextInt();
		int a1[] = new int[n];
		int a2[] = new int[n];
		int a3[] = new int[n];
		int b1[] = new int[m];
		int b2[] = new int[m];
		int sum1=0;
		int sum2=0;
		for(int i=0;i<n;i++) {
			a1[i]=sc.nextInt();
			a2[i]=sc.nextInt();
			a3[i]=sc.nextInt();
			s[i]=new Supply(a1[i],a2[i],a3[i]);
			sum1+=a2[i];
		}
		for(int i=0;i<m;i++) {
			b1[i]=sc.nextInt();
			b2[i]=sc.nextInt();
			sum2+=b2[i];
		}
		if(sum1<sum2) {
			System.out.println("-1");
		}
		else {
			Arrays.sort(s,0,n);
//			for(int i=0;i<n;i++) {
//				System.out.println(s[i].number+" "+s[i].max+" "+s[i].spend);
//			}
			int i=0,j=0;
			while(j!=m) {
				while(b2[j]!=0) {
					if(s[i].max<=b2[j])
					{
						b2[j]-=s[i].max;
						System.out.println(s[i].number+" "+b1[j]+" "+s[i].max);
						i++;
					}
					else {
						s[i].max-=b2[j];
						System.out.println(s[i].number+" "+b1[j]+" "+b2[j]);
						j++;
						if(j==m)
							break;
					}
				}
			}
		}
	}
}

运行结果:

4 4

0 20 8

1 15 3

2 55 6

3 40 10

0 28

1 36

2 49

3 12
1 0 15
2 0 13
2 1 36
2 2 6
0 2 20
3 2 23
3 3 12

总之,记两点:一,Java中想用结构体的话,就写个类来实现呗!二,要想对生成的对象数组进行排序,就在类中实现Comparable接口并在类中自定义compareTo()比较函数,用Arrays.sort()进行排序就好啦!

注:当然排序方法肯定不止这一种,但这一种是本人目前认为最简单的排序方法啦。哈哈哈,革命尚未成功,同志仍需努力呀!!!


  • 33
    点赞
  • 117
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
第1章 基本概念 1.1 概观:系统生命周期 1.2 指针和动态存储分配 1.3 算法形式规范 1.4 数据抽象 1.5 性能分析 1.6 性能度量 1.7 参考文献和选读材料 第2章 数组和结构 2.1 数组 2.2 数组的动态存储分配 2.3 结构体和联合体 2.4 多项式 2.5 稀松矩阵 2.6 多维数组的表示 2.7 字符串 2.8 参考文献和选读材料 2.9 补充习题 第3章 栈与队列 3.1 栈 .3.2 动态栈 3.3 队列 3.4 动态循环队列 3.5 迷宫问题 3.6 表达式求值 3.7 多重栈与多重队列 3.8 补充习题 第4章 链表 4.1 单向链表 4.2 用C语言表示单向链表 4.3 链式栈与链式队列 4.4 多项式 4.5 其它链表操作 4.6 等价类 4.7 稀疏矩阵 4.8 双向链表 第5章 树 5.1 引论 5.2 二叉树 5.3 遍历二叉树 5.4 其它二叉树操作 5.5 线索二叉树 5.6 堆 5.7 二叉查找树 5.8 选拔树 5.9 森林 5.10 不相交集合的表示 5.11 二叉树的计数 5.12 参考文献和选读材料 第6章 图 6.1 图的抽象数据类型 6.2 图的基本操作 6.3 最小代价生成树 6.4 最短路径和迁移闭包 6.5 活动网络 6.6 参考文献和选读材料 6.7 补充习题 第7章 排序 7.1 动机 7.2 插入排序 7.3 快速排序 7.4 排序最快有多快 7.5 归并排序 7.6 堆排序 7.7 多关键字排序 7.8 链表排序和索引表排序 7.9 内部排序小结 7.10 外部排序 7.11 参考文献和选读材料 第8章 Hash法 8.1 引言 8.2 静态Hash法 8.3 动态Hash法 8.4 Bloom滤波器 8.5 参考文献和选读材料 第9章 优先队列 9.1 单端优先队列和双端优先队列 9.2 左倾树 9.3 二项式堆 9.4 Fibonacci堆 9.5 配偶堆 9.6 对称最小-最大堆 9.7 区间堆 9.8 参考文献和选读材料 第10章 高效二叉查找树 10.1 最优二叉查找树 10.2 AVL树 10.3 红-黑树 10.4 Splay树 10.5 参考文献和选读材料 第11章 多路查找树 11.1 m-路查找树 11.2 B-树 11.3 B+树 11.4 参考文献和选读材料 第12章 数字查找结构 12.1 数字查找树 12. 2 二路Trie树和Patricia树 12.3 多路Trie树 12.4 后缀树 12.5 Trie树和互联网的包转发 12.6 参考文献和选读材料

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 8
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值