Java：如何编写'zip'函数？返回类型应该是什么？
Java：如何编写'zip'函数？返回类型应该是什么？,java,Java,zip函数的返回类型应该是什么？（zip与大多数其他语言一样，例如） 我考虑过一些Pair类型，但Java中不存在这种类型。经常有人说这是因为专门的Pair类比一般的Pair类更好（参见问题）。但是，这在常规的zip函数中是不可能的。不，标准JRE中没有明确的对（或任何元组） 你可能会感兴趣的javaposse Google组上有一个链接，链接到一篇文章，加上一个 更新-最初的问题是Java中是否有一对。这个答案可能不再有意义。这里是一个开始 public class Pair<T1,
zipzip我考虑过一些Pair类型，但Java中不存在这种类型。经常有人说这是因为专门的Pair类比一般的Pair类更好（参见问题）。但是，这在常规的
zip更新-最初的问题是Java中是否有一对。这个答案可能不再有意义。这里是一个开始
public class Pair<T1, T2>
{
private T1 first;
private T2 second;
public Pair(T1 first, T2 second)
{
this.first = first;
this.second = second;
}
public T1 getFirst()
{
return first;
}
public T2 getSecond()
{
return second;
}
}
公共类对
{
私人T1优先；
私人T2秒；
公共对（T1第一，T2第二）
{
this.first=first；
这个秒=秒；
}
公共T1 getFirst（）
{
先返回；
}
公共第二
{
返回第二；
}
}
public static <T> List<List<T>> zip(List<T>... lists) {
List<List<T>> zipped = new ArrayList<List<T>>();
for (List<T> list : lists) {
for (int i = 0, listSize = list.size(); i < listSize; i++) {
List<T> list2;
if (i >= zipped.size())
zipped.add(list2 = new ArrayList<T>());
else
list2 = zipped.get(i);
list2.add(list.get(i));
}
}
return zipped;
}
public static void main(String[] args) {
List<Integer> x = Arrays.asList(1, 2, 3);
List<Integer> y = Arrays.asList(4, 5, 6);
List<List<Integer>> zipped = zip(x, y);
System.out.println(zipped);
}
我回答Java“zip”问题纯粹是出于兴趣，我不建议这个解决方案，它不是一个函数，尽管你可以让它建立一个列表，如果你喜欢的话 可以使用以下命令在同一for循环中迭代两个列表
Iterator<Object> iterA=listA.iterator();
Iterator<Object> iterB=listB.iterator();
for (Object a=iterA.next(), b=iterB.next();
iterA.hasNext()&&iterB.hasNext();
a=iterA.next(), b=iterB.next()) {
...
}
Iterator iterA=listA.Iterator（）；
迭代器iterB=listB.Iterator（）；
for（对象a=iterA.next（），b=iterB.next（）；
iterA.hasNext（）和&iterB.hasNext（）；
a=iterA.next（），b=iterB.next（））{
...
}
这不是一个很好的解决方案。我想我已经使结对类几乎达到了完美：p
public class Pair<T1, T2> implements Iterable<Object>, Cloneable{
public static <X, Y> Pair<X, Y> makePair(X x, Y y){
return new Pair<X, Y>(x, y);
}
public static <X> Pair<X, X[]> makePairFromArray(X... xs){
if (xs.length == 0)
return new Pair<X, X[]>(null, null);
if (xs.length == 1)
return new Pair<X, X[]>(xs[0], null);
return new Pair<X, X[]>(xs[0], Arrays.copyOfRange(xs, 1, xs.length-1));
}
public static <X, Y> Pair<X, Y> reverse(Pair<Y, X> original){
return makePair(original.getSecond(), original.getFirst());
}
public static synchronized <X> void swap(Pair<X, X> swapped){
X tmp = swapped.getFirst();
swapped.setFirst(swapped.getSecond());
swapped.setSecond(tmp);
}
@SuppressWarnings("unchecked")
public static <X, Y> List<Object> asObjectList(Pair<X, Y> pair){
return asList((Pair<Object, Object>) pair);
}
public static <X, Y> Object[] asObjectArray(Pair<X, Y> pair, Object[] array){
return asObjectList(pair).toArray(array);
}
public static <X> List<X> asList(Pair<X, X> pair){
ArrayList<X> list = new ArrayList<X>();
list.add(pair.getFirst());
list.add(pair.getSecond());
return list;
}
public static <X> X[] asArray(Pair<X, X> pair, X[] array){
return asList(pair).toArray(array);
}
public static <X> Iterator<X> typedIterator(Pair<X, X> pair){
@SuppressWarnings("unchecked")
final Iterator<X> it = (Iterator<X>) pair.iterator();
return it;
}
public static <X> boolean isSymmetric(Pair<X, X> pair){
return pair.equals(reverse(pair));
}
public static <X> boolean isReflexive(Pair<X, X> pair){
X x1 = pair.getFirst();
X x2 = pair.getSecond();
if (x1 == null && x2 == null) return true;
if (x1 == null && x2 != null) return false;
if (x1 != null && x2 == null) return false;
return x1.equals(x2);
}
public static <X, Y, Z> boolean isTransitive(Pair<X, Y> first, Pair<Y, Z> second){
Y y1 = first.getSecond();
Y y2 = second.getFirst();
if (y1 == null && y2 == null) return true;
if (y1 == null && y2 != null) return false;
if (y1 != null && y2 == null) return false;
return y1.equals(y2);
}
public static synchronized <X, Y> Pair<X, Y> immutablePair(Pair<X, Y> pair){
final Pair<X, Y> wrapped = pair;
return new Pair<X, Y>(null, null){
@Override
public X getFirst() {
return wrapped.getFirst();
}
@Override
public Y getSecond() {
return wrapped.getSecond();
}
@Override
public void setFirst(X first) {
throw new UnsupportedOperationException();
}
@Override
public void setSecond(Y second) {
throw new UnsupportedOperationException();
}
@Override
public int hashCode() {
return wrapped.hashCode();
}
@Override
public boolean equals(Object obj) {
return wrapped.equals(obj);
}
@Override
public String toString() {
return wrapped.toString();
}
@Override
public Iterator<Object> iterator() {
return wrapped.iterator();
}
@Override
public Object clone() throws CloneNotSupportedException {
return wrapped.clone();
}
@Override
public Pair<X, Y> copy() {
return wrapped.copy();
}
};
}
public static synchronized <X, Y> Pair<X, Y> synchronizedPair(Pair<X, Y> pair){
final Pair<X, Y> wrapped = pair;
return new Pair<X, Y>(null, null){
@Override
public synchronized X getFirst() {
return wrapped.getFirst();
}
@Override
public synchronized void setFirst(X first) {
wrapped.setFirst(first);
}
@Override
public synchronized Y getSecond() {
return wrapped.getSecond();
}
@Override
public synchronized void setSecond(Y second) {
wrapped.setSecond(second);
}
@Override
public synchronized int hashCode() {
return wrapped.hashCode();
}
@Override
public synchronized boolean equals(Object obj) {
return wrapped.equals(obj);
}
@Override
public synchronized String toString() {
return wrapped.toString();
}
@Override
public synchronized Iterator<Object> iterator() {
return wrapped.iterator();
}
@Override
public synchronized Object clone() throws CloneNotSupportedException {
return wrapped.clone();
}
@Override
public synchronized Pair<X, Y> copy() {
return wrapped.copy();
}
};
}
public Pair(T1 first, T2 second) {
super();
this.first = first;
this.second = second;
}
public Pair(){
super();
this.first = null;
this.second = null;
}
public Pair(Pair<T1, T2> copy) {
first = copy.first;
second = copy.second;
}
private T1 first;
private T2 second;
public T1 getFirst() {
return first;
}
public void setFirst(T1 first) {
this.first = first;
}
public T2 getSecond() {
return second;
}
public void setSecond(T2 second) {
this.second = second;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((first == null) ? 0 : first.hashCode());
result = prime * result + ((second == null) ? 0 : second.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
@SuppressWarnings("rawtypes")
Pair other = (Pair) obj;
if (first == null) {
if (other.first != null)
return false;
} else if (!first.equals(other.first))
return false;
if (second == null) {
if (other.second != null)
return false;
} else if (!second.equals(other.second))
return false;
return true;
}
@Override
public String toString() {
return "(" + first + ", " + second + ")";
}
@Override
public Iterator<Object> iterator() {
return new Iterator<Object>(){
private int it = 0;
@Override
public boolean hasNext() {
return it != 2;
}
@Override
public Object next() {
return (it++) == 0 ? first : second;
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
};
}
@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
public Pair<T1, T2> copy(){
return makePair(first, second);
}
}
公共类对实现了Iterable、Cloneable{
公共静态对makePair（X，Y）{
返回新的一对（x，y）；
}
公共静态对makePairFromArray（X…xs）{
如果（xs.length==0）
返回新对（null，null）；
如果（xs.length==1）
返回新对（xs[0]，null）；
返回新的对（xs[0]，Arrays.copyOfRange（xs，1，xs.length-1））；
}
公共静态对反向（对原始）{
返回makePair（original.getSecond（），original.getFirst（））；
}
公共静态同步无效交换（成对交换）{
X tmp=swapped.getFirst（）；
swapped.setFirst（swapped.getSecond（））；
交换。设置秒（tmp）；
}
@抑制警告（“未选中”）
公共静态列表asObjectList（成对）{
返回asList（（对）对）；
}
公共静态对象[]asObjectArray（对对，对象[]数组）{
返回一个对象列表（对）.toArray（数组）；
}
公共静态列表asList（成对）{
ArrayList=新建ArrayList（）；
添加（pair.getFirst（））；
添加（pair.getSecond（））；
退货清单；
}
公共静态X[]asArray（对对，X[]数组）{
返回asList（对）.toArray（数组）；
}
公共静态迭代器typedIterator（成对）{
@抑制警告（“未选中”）
final Iterator it=（Iterator）pair.Iterator（）；
归还它；
}
公共静态布尔isSymmetric（对）{
返回对。等于（反向（对））；
}
公共静态布尔值isReflexive（成对）{
X x1=pair.getFirst（）；
X x2=pair.getSecond（）；
如果（x1==null&&x2==null）返回true；
如果（x1==null&&x2！=null）返回false；
如果（x1！=null&&x2==null）返回false；
返回x1等于（x2）；
}
公共静态布尔值isTransitive（第一对，第二对）{
Y y1=first.getSecond（）；
Y y2=second.getFirst（）；
如果（y1==null&&y2==null）返回true；
如果（y1==null&&y2！=null）返回false；
如果（y1！=null&&y2==null）返回false；
返回y1。等于（y2）；
}
公共静态同步对immutablePair（对对）{
最后一对包裹=一对；
返回新对（null，null）{
@凌驾
公共X getFirst（）{
返回wrapped.getFirst（）；
}
@凌驾
公共Y getSecond（）{
返回wrapped.getSecond（）；
}
@凌驾
公共无效设置优先（X优先）{
抛出新的UnsupportedOperationException（）；
}
@凌驾
公共无效设置秒（Y秒）{
抛出新的UnsupportedOperationException（）；
}
@凌驾
公共int hashCode（）{
返回wrapped.hashCode（）；
}
@凌驾
公共布尔等于（对象obj）{
返回包装。等于（obj）；
}
@凌驾
公共字符串toString（）{
return wrapped.toString（）；
}
@凌驾
公共迭代器迭代器（）{
返回wrapped.iterator（）；
}
@凌驾
公共对象克隆（）引发CloneNotSupportedException{
返回wrapped.clone（）；
}
@凌驾
公共对副本（）{
返回wrapped.copy（）；
}
};
}
公共静态同步对synchronizedPair（对对）{
最后一对包裹=一对；
返回新对（null，null）{
@凌驾
公共同步X getFirst（）{
返回wrapped.getFirst（）；
}
@凌驾
公共同步的void setFirst（X优先）{
包装。设置第一（第一）；
}
@凌驾
公共同步Y getSecond（）{
返回wrapped.getSecond（）；
}
@凌驾
公共电视
public class Pair<T1, T2> implements Iterable<Object>, Cloneable{
public static <X, Y> Pair<X, Y> makePair(X x, Y y){
return new Pair<X, Y>(x, y);
}
public static <X> Pair<X, X[]> makePairFromArray(X... xs){
if (xs.length == 0)
return new Pair<X, X[]>(null, null);
if (xs.length == 1)
return new Pair<X, X[]>(xs[0], null);
return new Pair<X, X[]>(xs[0], Arrays.copyOfRange(xs, 1, xs.length-1));
}
public static <X, Y> Pair<X, Y> reverse(Pair<Y, X> original){
return makePair(original.getSecond(), original.getFirst());
}
public static synchronized <X> void swap(Pair<X, X> swapped){
X tmp = swapped.getFirst();
swapped.setFirst(swapped.getSecond());
swapped.setSecond(tmp);
}
@SuppressWarnings("unchecked")
public static <X, Y> List<Object> asObjectList(Pair<X, Y> pair){
return asList((Pair<Object, Object>) pair);
}
public static <X, Y> Object[] asObjectArray(Pair<X, Y> pair, Object[] array){
return asObjectList(pair).toArray(array);
}
public static <X> List<X> asList(Pair<X, X> pair){
ArrayList<X> list = new ArrayList<X>();
list.add(pair.getFirst());
list.add(pair.getSecond());
return list;
}
public static <X> X[] asArray(Pair<X, X> pair, X[] array){
return asList(pair).toArray(array);
}
public static <X> Iterator<X> typedIterator(Pair<X, X> pair){
@SuppressWarnings("unchecked")
final Iterator<X> it = (Iterator<X>) pair.iterator();
return it;
}
public static <X> boolean isSymmetric(Pair<X, X> pair){
return pair.equals(reverse(pair));
}
public static <X> boolean isReflexive(Pair<X, X> pair){
X x1 = pair.getFirst();
X x2 = pair.getSecond();
if (x1 == null && x2 == null) return true;
if (x1 == null && x2 != null) return false;
if (x1 != null && x2 == null) return false;
return x1.equals(x2);
}
public static <X, Y, Z> boolean isTransitive(Pair<X, Y> first, Pair<Y, Z> second){
Y y1 = first.getSecond();
Y y2 = second.getFirst();
if (y1 == null && y2 == null) return true;
if (y1 == null && y2 != null) return false;
if (y1 != null && y2 == null) return false;
return y1.equals(y2);
}
public static synchronized <X, Y> Pair<X, Y> immutablePair(Pair<X, Y> pair){
final Pair<X, Y> wrapped = pair;
return new Pair<X, Y>(null, null){
@Override
public X getFirst() {
return wrapped.getFirst();
}
@Override
public Y getSecond() {
return wrapped.getSecond();
}
@Override
public void setFirst(X first) {
throw new UnsupportedOperationException();
}
@Override
public void setSecond(Y second) {
throw new UnsupportedOperationException();
}
@Override
public int hashCode() {
return wrapped.hashCode();
}
@Override
public boolean equals(Object obj) {
return wrapped.equals(obj);
}
@Override
public String toString() {
return wrapped.toString();
}
@Override
public Iterator<Object> iterator() {
return wrapped.iterator();
}
@Override
public Object clone() throws CloneNotSupportedException {
return wrapped.clone();
}
@Override
public Pair<X, Y> copy() {
return wrapped.copy();
}
};
}
public static synchronized <X, Y> Pair<X, Y> synchronizedPair(Pair<X, Y> pair){
final Pair<X, Y> wrapped = pair;
return new Pair<X, Y>(null, null){
@Override
public synchronized X getFirst() {
return wrapped.getFirst();
}
@Override
public synchronized void setFirst(X first) {
wrapped.setFirst(first);
}
@Override
public synchronized Y getSecond() {
return wrapped.getSecond();
}
@Override
public synchronized void setSecond(Y second) {
wrapped.setSecond(second);
}
@Override
public synchronized int hashCode() {
return wrapped.hashCode();
}
@Override
public synchronized boolean equals(Object obj) {
return wrapped.equals(obj);
}
@Override
public synchronized String toString() {
return wrapped.toString();
}
@Override
public synchronized Iterator<Object> iterator() {
return wrapped.iterator();
}
@Override
public synchronized Object clone() throws CloneNotSupportedException {
return wrapped.clone();
}
@Override
public synchronized Pair<X, Y> copy() {
return wrapped.copy();
}
};
}
public Pair(T1 first, T2 second) {
super();
this.first = first;
this.second = second;
}
public Pair(){
super();
this.first = null;
this.second = null;
}
public Pair(Pair<T1, T2> copy) {
first = copy.first;
second = copy.second;
}
private T1 first;
private T2 second;
public T1 getFirst() {
return first;
}
public void setFirst(T1 first) {
this.first = first;
}
public T2 getSecond() {
return second;
}
public void setSecond(T2 second) {
this.second = second;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((first == null) ? 0 : first.hashCode());
result = prime * result + ((second == null) ? 0 : second.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
@SuppressWarnings("rawtypes")
Pair other = (Pair) obj;
if (first == null) {
if (other.first != null)
return false;
} else if (!first.equals(other.first))
return false;
if (second == null) {
if (other.second != null)
return false;
} else if (!second.equals(other.second))
return false;
return true;
}
@Override
public String toString() {
return "(" + first + ", " + second + ")";
}
@Override
public Iterator<Object> iterator() {
return new Iterator<Object>(){
private int it = 0;
@Override
public boolean hasNext() {
return it != 2;
}
@Override
public Object next() {
return (it++) == 0 ? first : second;
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
};
}
@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
public Pair<T1, T2> copy(){
return makePair(first, second);
}
}