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

最新推荐文章于 2025-06-30 11:44:01 发布

原创最新推荐文章于 2025-06-30 11:44:01 发布 · 4.8w 阅读

129 ·

CC 4.0 BY-SA版权

Java 专栏收录该内容

19 篇文章

订阅专栏

本文介绍了如何在Java中使用类来模拟C/C++中的结构体，并实现对象数组的自定义排序。通过具体示例展示了两种实现结构体的方法及排序过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

***今天在做老师布置的编程题时，遇到了本题。感觉这道题如果用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); 
    }  
}

运行结果：

【问题描述】

有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;
					}
				}
			}
		}
	}
}

运行结果：

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

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