概述
Java整型集合类练习
定义一个整型集合类，这个类型的对象可以存储10个20-80之间的整数，即它的内部有一个整型数组存储数据。编程：
1、判断两个这个类对象s1，s2是否相等。
2、输出两个集合对象的交集。
3、输出两个集合对象的并集。
4、将一个整型数据插入到一个集合对象中。
5、从一个集合中删除某一个元素。
第一种解法：数组+for
package hello;
public class leng
{
int a[];
int b[];
leng(int []a,int []b) //带参数的构造函数；
{
this.a=a;
this.b=b;
}
void Equal(int e[],int f[]) //判断两个数组是否相等，并输出交集
{ System.out.print("n交集为：");
int count = 0;
for(int j=0;j<10;j++)
{
for(int h=0;h<10;h++)
{
if(e[j]==f[h])
{
count++;//统计两个数组中相等的数的个数
System.out.print(e[j]+" ");//把相等的元素拿出来放在交集输出来
break;
}
}
}
if(count==10)//两集合元素完全相等的情况
{
System.out.print("nS1=S2");
}
else
{
System.out.print("nS1!=S2");
}
}
//思路：先输出一个数组，再输出另一个数组中不在该数组中的元素即为并集。
//例如：int[] a = {1,2,3};int[] b = {2,3,4};先输出1，2，3，又4在b中且不在a中，则输出4.
void Union(int e[],int f[])//求并集的方法
{ System.out.print("n并集为:");
int flag=0;
for(int i=0;i<10;i++)
{
System.out.print(e[i]+" ");//输出e数组的元素
}
//注意此循坏的for作业的范围。
for(int j = 0;j<10;j++)
{
for(int h = 0;h<10;h++)
{
if(f[j]==e[h])
{
flag++;
}
}
if(flag==0)
{
System.out.print(f[j]+" ");
}
else
{
flag=0;
}
}
}
void Insert(int a,int b[])//将整数插入到集合a中的方法
{
int c[];
c = new int[11];
for(int i=0;i<10;i++)
{
c[i]=b[i];
}
c[10]=a;
System.out.print("n将整数"+a+"插入到集合a中后的结果为:");
for(int j :c)//高级for循环。格式：for(要遍历的对象的元素的数据类型 变量名 : 要遍历对象的名字)
{
System.out.print(j+" ");
}
}
void Del(int a,int b[])
{
int c[];
int i,j = 0;
c=new int[9];
for(i=0;i<10;i++)//找到要删除的元素的位置。
{
if(b[i]==a)
{
j=i;
}
}
for(i=0;i<j;i++)
{
c[i]=b[i];
}
for(i=j;i<c.length;i++)
{
c[i]=b[i+1];
}
System.out.print("n将元素"+a+"从集合a中移除后的结果为:");
for(i=0;i<9;i++)
{
System.out.print(c[i]+" ");
}
}
public static void main(String[] args) {
int a[]= {21,22,23,24,25,26,27,28,29,30};
int b[]= {26,26,28,29,30,31,32,33,34,35};
System.out.print("集合a:");
for(int i=0;i<10;i++)
{
System.out.print(a[i]+" ");
}
System.out.print("n集合b:");
for(int i=0;i<10;i++)
{
System.out.print(b[i]+" ");
}
leng asd=new leng (a,b);
asd.Equal(a, b);
asd.Union(a, b);
asd.Insert(99,a);
asd.Del(22,a);
}
}
#集合a:21 22 23 24 25 26 27 28 29 30
集合b:26 26 28 29 30 31 32 33 34 35
交集为：26 28 29 30
S1!=S2
并集为:21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
将整数99插入到集合a中后的结果为:21 22 23 24 25 26 27 28 29 30 99
将元素22从集合a中移除后的结果为:21 23 24 25 26 27 28 29 30
第二种解法：利用Arraylist动态数组的特性。
package hello;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
class integerSet{
Integer a[],b[];
//定义中间变量result。
（#）ArrayList<Integer> result = new ArrayList<Integer>();
ArrayList<Integer> list1,list2;
integerSet(Integer[] a,Integer[] b) {
this.a = a;
this.b = b;
list1 = new ArrayList<Integer>(Arrays.asList(a));
list2 = new ArrayList<Integer>(Arrays.asList(b));
}
//判断两个集合是否相等
void Equals() {
String string = list1.equals(list2)?"S1==S2":"S1!=S2";
System.out.println(string);
}
//求交集
void intersection() {
（*）//ArrayList<Integer> result = new ArrayList<Integer>();
//result = list1;
//此方法中list1会发生改变，故在这里先将list1的内容通过for循环单个赋值给result
(#)for( Integer i: list1)
result.add(i);
（1）list1.retainAll(list2);//将list1与list2的交集赋给list1。
（2）System.out.println(list1);
}
//求并集
void Union() {
//从此处开始都要将list1或list2重新赋值，注意（1）处的注释。则（2）处的list1为[26, 28, 29, 30]。故接下来的所有操作都会以这个值最为基准进行运算。
/*
* 有些人可能会想到先用一个中间变量暂时储存list1未做（1）处运算之前
* 的内容，之后在将result赋值给list1做之后的计算。例如（*）处。
* 可Arraylist是动态数组，数组是引用类型。只要list1与result中的一个的内容发生改变，
* 另一个就会随之发生改变。故这种方法不可取。故可采取在之后的方法中，让list1与list2
* 都回到初始值。这样就符合题意。
* 但也可采用中间变量的方法但不是直接赋值，而是利用for循环单个赋值。
* 具体见（#）处代码块（空行处结束）运行时，将（*）代替（|)的代码即可得到相同的结果
*/
(#)list1.clear();
//将交集中的list1的内容清空（每次使用都要清空，否则使用的便是上一次运算的结果）
for(Integer i:result)
list1.add(i);//把list1的原始值赋给list1
(|)list1 = new ArrayList<Integer>(Arrays.asList(a));
(|)list2 = new ArrayList<Integer>(Arrays.asList(b));
System.out.println("S1与S2的并集为：");
list2.removeAll(list1);
list1.addAll(list2);
System.out.println(list1);
}
//插入一个数
void Insert(Integer i) {
（#）list1.clear();
for(Integer k:result)
list1.add(k);
(|)list1 = new ArrayList<Integer>(Arrays.asList(a));
System.out.println("将i插入到list1中的结果为：");
list1.add(i);
System.out.println(list1);
}
//删除
void Del(int j) {
（#）list1.clear();
for(Integer k:result)
list1.add(k);
(|) list1 = new ArrayList<Integer>(Arrays.asList(a));
System.out.println("将j从list1中删除的结果为：");
list1.remove(new Integer(j));
//remove(int index)传入的参数是整型，删除的是索引号为index的元素
//remove(object obj)传入的是对象，删除的是只为obj的元素
System.out.println(list1);
}
}
public class Person {
public static void main(String[] args) {
// TODO 自动生成的方法存根
Integer[] a = { 21,22,23,24,25,26,27,28,29,30};
Integer[] b= {26,26,28,29,30,31,32,33,34,35};
integerSet i = new integerSet(a,b);
//各个方法可以不用带参数，a与b已经通过构造函数将其赋值给
//ItegerSet中的a与b作为全局变量供各个方法使用，带上参数显多余。
i.Equals();
i.intersection();
i.Union();
i.Insert(99);
i.Del(22);
}
}
#
S1!=S2
S1与S2的交集为：
[26, 28, 29, 30]
S1与S2的并集为：
[21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35]
将i插入到list1中的结果为：
[21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 99]
将j从list1中删除的结果为：
[21, 23, 24, 25, 26, 27, 28, 29, 30]
第三种解法：Arraylist数组+for
package hello;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.omg.CosNaming.IstringHelper;
class integerSet{
ArrayList<Integer>list = new ArrayList<Integer>();
//判断两个集合是否相等
void Equals(integerSet s) {//这里包含两个对象，自身与s。
//注意s.list.equals处，不要写出s.equals。其中s是【自身对象】，而不是Arraylist数组。
String string = s.list.equals(list)?"S1==S2":"S1!=S2";
System.out.println(string);
}
//求交集
void intersection(integerSet s) {
ArrayList<Integer> result = new ArrayList<Integer>();
System.out.println("S1与S2的交集为：");
for (Integer i:list) {//高级for循环
if(s.list.contains(i))//不可写出s.contains(),否则会报错。
result.add(i);
}
System.out.println(result);
}
//求并集
void Union(integerSet s) {
ArrayList<Integer> result = new ArrayList<Integer>();
System.out.println("S1与S2的并集为：");
for(Integer i:list)
result.add(i);
for(Integer i:s.list) {
if(!result.contains(i))
result.add(i);
}
System.out.println(result);
}
//插入一个数
void Insert(int n) {
ArrayList<Integer> result = new ArrayList<Integer>();
System.out.println("将"+n+"插入到s1中的结果为：");
for(Integer i:list)
result.add(i);
result.add(n);
System.out.println(result);
}
//删除
void Del(Integer j) {
System.out.println("将"+j+"从s1中删除的结果为：");
list.remove(j);
System.out.println(list);
}
}
public class Person {
public static void main(String[] args) {
// TODO 自动生成的方法存根
//不可将Integer改为int。Arraylist数组中的元素类型不能为基本数据类型。
Integer[] a = { 21,22,23,24,25,26,27,28,29,30};
Integer[] b= {26,26,28,29,30,31,32,33,34,35};
ArrayList<Integer> list1,list2;
//将Integer型数组转化为Arraylist数组
list1 = new ArrayList<Integer>(Arrays.asList(a));
list2 = new ArrayList<Integer>(Arrays.asList(b));
integerSet s1 = new integerSet();
integerSet s2 = new integerSet();
s1.list =list1;;
s2.list = list2;
s1.Equals(s2);
s1.intersection(s2);
s1.Union(s2);
s1.Insert(99);
s1.Del(22);
}
}
#
S1!=S2
S1与S2的交集为：
[26, 28, 29, 30]
S1与S2的并集为：
[21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35]
将99插入到s1中的结果为：
[21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 99]
将22从s1中删除的结果为：
[21, 23, 24, 25, 26, 27, 28, 29, 30]
最后
以上就是忐忑荔枝为你收集整理的Java整型集合类练习（一题多解）的全部内容，希望文章能够帮你解决Java整型集合类练习（一题多解）所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
发表评论 取消回复