java如何探测数组当中相同的连续值？

package com.zhukovasky.audio;

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

public class LinkIntegerArrays{
	private List<Integer> listIntegerArrays;
	private Integer lastPositions;
	private Integer BeginPositions;
	public LinkIntegerArrays(Integer index){
		this.BeginPositions=index;
		init();
		this.lastPositions=this.listIntegerArrays.get(this.listIntegerArrays.size()-1);
	}
	private void init(){
		this.listIntegerArrays=new ArrayList<Integer>();
		this.listIntegerArrays.add(0, BeginPositions);
	}
	public void addInteger(Integer intElements){
		this.listIntegerArrays.add(intElements);
	}
	public boolean isExist(Integer intElement){
		boolean flag=false;
		for(Integer iter:this.listIntegerArrays){
			if(intElement==iter){
				flag=true;
				break;
			}
		}
		return flag;
	}
	public int Length(){
		return this.listIntegerArrays.size();
	}
	public Integer getLastPositions() {
		return lastPositions;
	}
	public void setLastPositions(Integer lastPositions) {
		this.lastPositions = lastPositions;
	}
	public Integer getBeginPositions() {
		return BeginPositions;
	}
	public void setBeginPositions(Integer beginPositions) {
		BeginPositions = beginPositions;
	}
	public String toString(){
		return this.listIntegerArrays.toString();
	}
}
package com.zhukovasky.audio;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class LinkToList {
	private List<LinkIntegerArrays> links;
	//private LinkIntegerArrays iterator;
	public LinkToList(){
		init();
		//this.iterator=this.links.iterator().next();
	}
	private void init(){
		this.links=new ArrayList<LinkIntegerArrays>();
	}
	public void addByKey(Integer PreIndex){
		if(this.links.isEmpty()){
			LinkIntegerArrays linkArrays=new LinkIntegerArrays(PreIndex);
			this.links.add(0, linkArrays);
		}
		if(this.links.get(this.links.size()-1).getLastPositions()==PreIndex-1){
			this.links.get(this.links.size()-1).addInteger(PreIndex);
			this.links.get(this.links.size()-1).setLastPositions(PreIndex);
		}
		if(this.links.get(this.links.size()-1).getLastPositions()<PreIndex-1){
			LinkIntegerArrays linksArrays=new LinkIntegerArrays(PreIndex);
			this.links.add(linksArrays);
		}
	}
	public boolean isExist(Integer TargetIndex){
		boolean flag=false;
		Integer[] PreIndex=new Integer[this.getSize()];
		for(int i=0;i<PreIndex.length;i++){
			PreIndex[i]=this.links.get(i).getBeginPositions();
		}
		int it=Arrays.binarySearch(PreIndex, TargetIndex);
		if(it<0){
			int index=getIndex(PreIndex,TargetIndex);
			if(index==-1){
				flag=false;
			}else{
				flag=this.links.get(index).isExist(TargetIndex);
			}
		}else{
			flag=true;
		}
		return flag;
	}
	private static int getIndex(Integer[]  ints,Integer TargetIndex){
		int targetindex=-1;
		for(int i=0;i<ints.length;i++){
			if(TargetIndex<ints[i]){
				targetindex=i;
			}
		}
		return targetindex;
	}
	public int getSize(){
		return this.links.size();
	}
	public int DetectSilence(int length){
		int count=0;
		for(LinkIntegerArrays link:this.links){
			if(link.Length()>=length){
				count++;
			}
		}
		return count;
	}
	public Integer[] detectSilence(int length){
		int count=this.DetectSilence(length);
		Integer[] index=new Integer[count];
		List<Integer> indexmarks=new ArrayList<Integer>();
		for(LinkIntegerArrays link:this.links){
			if(link.Length()>=length){
				indexmarks.add(link.getLastPositions());
			}
		}
		System.out.println(indexmarks.size());
		return indexmarks.toArray(index);
	}
	public String toString(){
		return this.links.toString();
	}
}

这个问题我想了一天，刚开始采用数组。但是后来发现不对，没有办法生成链表+数组的存储结构。晚上想明白，实际上java的面向对象的思想就已经提供了很好的方法。

这是我用来处理相同值得处理办法。废话不多说，举个例子。

已知数组：[1,2,3,3,3,3,3,4,4,4,5,6,7,8,1,2,3,4,5,6,7,78,8,9,0,6,6,5,4,3,,2,3,4,5,6,7,7,8,23]。现在需求是将连续为3的长度大于一定阀值给提取出来。

现在解决的办法：贴上源代码。