Question

java问题求解答~

求编一个java程序：给一个LIST{2，5，5，6，6，7，7，8，2，4，5，5，6，6，7，9}，输出{5，5，6，6，7}，就是输出最长的相同子集，怎么编，最好能写点注释，我是新手，很悲剧。。。
public class LongestSame {

public static Integer longestSub(ArrayList<Integer> list) {
}
}
谁的方法正确又简单给谁分~

Answer 1

首先说几点：
1 你的方法提炼有些不恰当，你的返回值设为一个Integer，这能返回什么呢？返回值可以有两种方式：1）你返回符合结果的开始数的下标(这里就是1)和最长的长度(这里是5)
2）直接就把符合条件的结果做成一个list返回出来(我就是采用这种方法)
2 对于注释，时间仓促点 ，代码里没写。但是：：：你要明白，写程序不是说开始出来就写，闷头写，最重要的是你一开始就要知道这个过程是怎样实现的，这里我简述下：
对于要符合你所描述的条件，要怎样去实现呢，首先我要从这个list的第一个数(2)开始，到后面找到第二个2，然后分别比较第一个2和第二个2后面的数，一直比较到不相等的两个数，记录长度(这里就是1，结果就是{2})；然后再从第二个数(5)开始，按照上面的方法比较，记录结果长度是5，也就是{5,5,6,6,7} 。。。。。就是这样比较下去，就能知道最长结果了

望采纳：：：

import java.util.ArrayList;
import java.util.List;

public class Test {
public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
list.add(2);
.........
list.add(9);
List<Integer> result = longestSub(list);
for (Integer i : result) {
System.out.print(i + "\t");
}
}

private static List<Integer> longestSub(List<Integer> list) {
List<Integer> result = new ArrayList<Integer>();
int lflag, rflag, resultFrom, resultSize = 1, maxResultFrom = 0, maxResultSize = 1;
for (int i = 0; i < list.size() - 1; i++) {
for (int j = i + 1; j < list.size(); j++) {
if (list.get(i) == list.get(j)) {
resultFrom = i;
lflag = i + 1;
rflag = j + 1;
while (list.get(lflag++) == list.get(rflag++)) {
resultSize++;
}
if (resultSize > maxResultSize) {
maxResultFrom = resultFrom;
maxResultSize = resultSize;
}
resultSize = 1;
}
}
}
for (int i = maxResultFrom; i < maxResultFrom + maxResultSize; i++) {
result.add(list.get(i));
}
return result;
}
}

Answer 2

嗯 明天来答~ 今天放假

Answer 3

见代码:
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class LongestSame {
public static void main(String[] args) {
//测试数据
ArrayList<Integer> a = new ArrayList<Integer>();
a.add(3);
a.add(1);
a.add(12);
a.add(42);
a.add(3);
a.add(47);
a.add(3);
a.add(42);
//输出最长的相同子集
System.out.println("最长的相同子集=" + LongestSame.longestSub(a));
}

public static List<Integer> longestSub(ArrayList<Integer> list) {
//将list按从小到大的顺序排序
Collections.sort(list);
//计数器
int count = 0;
//最大元素个数
int max = 0;
//最大元素数值
Integer flag = null;
List<Integer> subList = new ArrayList<Integer>();
for (int i = 0; i < list.size(); i++) {
//判断是否存在该元素，存在则计数器count加1
if (flag != null && flag.intValue() == list.get(i).intValue()) {
count++;
//当最大子集不唯一
if (count == max) {
//装填子集元素
for (int j = 0; j < max; j++) {
subList.add(list.get(i));
}
}
//当最大子集唯一时
if (count > max) {
max = count;
//清空原有子集元素
subList.clear();
//装填新的子集元素
for (int j = 0; j < max; j++) {
subList.add(list.get(i));
}
}
} else {
//当元素不存在时，将计数器初始化为1
flag = list.get(i);
count = 1;
}
}
//返回子集元素list
return subList;
}

}

Answer 4

我这里用的是数组，功能一样
public class LongestSame {
private int[] lists;

//初始化lists
public LongestSame(){
lists = new int[]{2,5,5,6,6,7,7,8,2,4,5,5,6,6,7,9};
getList();
}

public void getList(){
//从list[0]开始取,最长为list.length-1,除本身外，试想一下，如果全是1
//定义两个数组来存储相同长度的数字
int []list1,list2;
if(lists != null) {
//循环lists数组里面的值,15个到1个
for(int i=0; i<lists.length-1; i++) {
list1 = new int[lists.length-i-1];
list2 = new int[lists.length-i-1];
//这个循环是为了区分当list1开始从第m个数字记数时，第二个list2可以从往前一个"m+1"或往后第"m-j"个开始记数
for(int j=0; j<i+1; j++) {
//用来记相同数字循最多的次数,循环时会从多到少即15个到1个
int number=0;
//这个循环开始记数
for(int m=i; m<lists.length-1; m++) {
list1[m-i] = lists[m];
list2[m-i] = lists[m+1];
//当list1从第二个数开始记数时，list2就可以从前后记数
if(j>0) {
list2[m-i] = lists[m-j];
}
//当两个数相同
if(list1[m-i] == list2[m-i]) {
number++;
//当记数为最多时
if(number == (lists.length-i-1)) {
System.out.print("最长的相同子集是：");
for(int n=0; n<list1.length; n++) {
System.out.print(list1[n]+",");
}
return;
}
}
}
}
}
}
}

public static void main(String[] args) {
new LongestSame();
}
}
记得要给分,呵呵花了一个多钟呢

Answer 5

统计重复的数字个数，把大于1的集合在一起。

Answer 6

你为什么要写成(ItemListener) this那样子呢？
对象.additemListener()的这个方法，方法的参数就是一个继承了监听器类的类、或者是一个实现了监听器接口的类。因此，通常的使用方法有如下两种：
1.让主类去实现监听器接口，然后，对象.additemListener(this)，并且，在主类中重写相应的方法（如actionPerform()）；
2.直接：
对象.additemListener(new java.awt.event.ActionListener());
一般都是通过以上的两个方法实现事件的监听的，而不用“(ItemListener) this”这么别扭的写法，也没什么必要。