Java/Collections Data Structure/Array Collections — различия между версиями
Admin (обсуждение | вклад) м (1 версия) |
|
(нет различий)
|
Текущая версия на 10:24, 1 июня 2010
Содержание
- 1 ArrayEnumeration class (implements Enumeration)
- 2 Array Int Set
- 3 Array Set
- 4 Convert an Array to a List
- 5 Convert an array to a Map
- 6 Converting a Collection of String to an Array
- 7 Converting a Collection of user objects to an Array
- 8 Converting an Array to a Collection
- 9 Converts array into a java.util.Map.
- 10 Custom ArrayMap implementation (extends AbstractMap)
- 11 Custom ArraySet implementation (extends AbstractSet)
- 12 Remove duplicate element from array
- 13 Treating an Array as an Enumeration
ArrayEnumeration class (implements Enumeration)
<source lang="java">
import java.lang.reflect.Array; import java.util.Enumeration; public class ArrayEnumeration implements Enumeration {
private final int size; private int cursor; private final Object array; public ArrayEnumeration(Object obj) { Class type = obj.getClass(); if (!type.isArray()) { throw new IllegalArgumentException("Invalid type: " + type); } size = Array.getLength(obj); array = obj; } public boolean hasMoreElements() { return (cursor < size); } public Object nextElement() { return Array.get(array, cursor++); } public static void main(String args[]) { Object obj = new int[] { 2, 3, 5, 8, 13, 21 }; ArrayEnumeration e = new ArrayEnumeration(obj); while (e.hasMoreElements()) { System.out.println(e.nextElement()); } try { e = new ArrayEnumeration(ArrayEnumeration.class); } catch (IllegalArgumentException ex) { System.out.println(ex.getMessage()); } }
}
</source>
Array Int Set
<source lang="java">
/*
* Copyright (c) 2002-2008 "Neo Technology," * Network Engine for Objects in Lund AB [1] * * This file is part of Neo4j. * * Neo4j is free software: you can redistribute it and/or modify * it under the terms of the GNU Affero General Public License as * published by the Free Software Foundation, either version 3 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Affero General Public License for more details. * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */
import java.util.HashSet; import java.util.Iterator; import java.util.Set; // use array for first few properties to decrease memory footprint (and // to some extent boost performance) for nodes/rels with few properties public class ArrayIntSet {
private int maxRelSize = 256; private int[] rels = new int[2]; // TODO: figure out if we need volatile here? private int arrayCount = 0; private Set<Integer> relationshipSet = null; public boolean add( int id ) { for ( int i = 0; i < arrayCount; i++ ) { if ( rels[i] == id ) { return false; } } if ( arrayCount == rels.length && rels.length * 2 <= maxRelSize ) { int newRels[] = new int[rels.length * 2]; System.arraycopy( rels, 0, newRels, 0, rels.length ); rels = newRels; } if ( arrayCount != -1 ) { if ( arrayCount < rels.length ) { rels[arrayCount++] = id; return true; } relationshipSet = new HashSet<Integer>(); for ( int i = 0; i < arrayCount; i++ ) { relationshipSet.add( rels[i] ); } arrayCount = -1; } return relationshipSet.add( id ); } public Iterator<Integer> iterator() { if ( arrayCount == -1 ) { return relationshipSet.iterator(); } return new ArrayIntIterator( rels, arrayCount ); } public boolean remove( int id ) { for ( int i = 0; i < arrayCount; i++ ) { if ( rels[i] == id ) { int[] dest = rels; if ( arrayCount - 1 < rels.length / 3 ) { dest = new int[rels.length / 2]; System.arraycopy( rels, 0, dest, 0, arrayCount ); } if ( i + 1 < dest.length && (arrayCount - i - 1) > 0 ) { System.arraycopy( rels, i + 1, dest, i, arrayCount - i - 1 ); rels = dest; } arrayCount--; return true; } } if ( arrayCount == -1 ) { return relationshipSet.remove( id ); } return false; } public Iterable<Integer> values() { if ( arrayCount == -1 ) { return relationshipSet; } return new ArrayIntIterator( rels, arrayCount ); } private static class ArrayIntIterator implements Iterator<Integer>, Iterable<Integer> { private int[] intArray; private int pos = -1; private int arrayCount; ArrayIntIterator( int[] array, int count ) { this.intArray = array; this.arrayCount = count; } public boolean hasNext() { return pos + 1 < arrayCount; } public Integer next() { return intArray[++pos]; } public void remove() { throw new UnsupportedOperationException(); } public Iterator<Integer> iterator() { return this; } } public boolean contains( int id ) { for ( int i = 0; i < arrayCount; i++ ) { if ( rels[i] == id ) { return true; } } if ( arrayCount == -1 ) { return relationshipSet.contains( id ); } return false; } public int size() { if ( arrayCount != -1 ) { return arrayCount; } return relationshipSet.size(); }
}
</source>
Array Set
<source lang="java">
/* Copyright (c) 2006, 2009, Carl Burch. License information is located in the
* com.cburch.logisim.Main source code and at www.cburch.ru/logisim/. */
import java.util.AbstractSet; import java.util.ConcurrentModificationException; import java.util.Iterator; import java.util.NoSuchElementException; public class ArraySet extends AbstractSet {
private static final Object[] EMPTY_ARRAY = new Object[0]; private class ArrayIterator implements Iterator { int itVersion = version; int pos = 0; // position of next item to return boolean hasNext = values.length > 0; boolean removeOk = false; public boolean hasNext() { return hasNext; } public Object next() { if(itVersion != version) { throw new ConcurrentModificationException(); } else if(!hasNext) { throw new NoSuchElementException(); } else { Object ret = values[pos]; ++pos; hasNext = pos < values.length; removeOk = true; return ret; } } public void remove() { if(itVersion != version) { throw new ConcurrentModificationException(); } else if(!removeOk) { throw new IllegalStateException(); } else if(values.length == 1) { values = EMPTY_ARRAY; ++version; itVersion = version; removeOk = false; } else { Object[] newValues = new Object[values.length - 1]; if(pos > 1) { System.arraycopy(values, 0, newValues, 0, pos - 1); } if(pos < values.length) { System.arraycopy(values, pos, newValues, pos - 1, values.length - pos); } values = newValues; --pos; ++version; itVersion = version; removeOk = false; } } } private int version = 0; private Object[] values = EMPTY_ARRAY; public ArraySet() { } public Object[] toArray() { return values; } public Object clone() { ArraySet ret = new ArraySet(); if(this.values == EMPTY_ARRAY) { ret.values = EMPTY_ARRAY; } else { ret.values = (Object[]) this.values.clone(); } return ret; } public void clear() { values = EMPTY_ARRAY; ++version; } public boolean isEmpty() { return values.length == 0; } public int size() { return values.length; } public boolean add(Object value) { int n = values.length; for(int i = 0; i < n; i++) { if(values[i].equals(value)) return false; } Object[] newValues = new Object[n + 1]; System.arraycopy(values, 0, newValues, 0, n); newValues[n] = value; values = newValues; ++version; return true; } public boolean contains(Object value) { for(int i = 0, n = values.length; i < n; i++) { if(values[i].equals(value)) return true; } return false; } public Iterator iterator() { return new ArrayIterator(); } public static void main(String[] args) throws java.io.IOException { ArraySet set = new ArraySet(); java.io.BufferedReader in = new java.io.BufferedReader( new java.io.InputStreamReader(System.in)); while(true) { System.out.print(set.size() + ":"); //OK for(Iterator it = set.iterator(); it.hasNext(); ) { System.out.print(" " + it.next()); //OK } System.out.println(); //OK System.out.print("> "); //OK String cmd = in.readLine(); if(cmd == null) break; cmd = cmd.trim(); if(cmd.equals("")) { ; } else if(cmd.startsWith("+")) { set.add(cmd.substring(1)); } else if(cmd.startsWith("-")) { set.remove(cmd.substring(1)); } else if(cmd.startsWith("?")) { boolean ret = set.contains(cmd.substring(1)); System.out.println(" " + ret); //OK } else { System.out.println("unrecognized command"); //OK } } }
}
</source>
Convert an Array to a List
<source lang="java">
import java.util.Arrays; import java.util.List; public class Main {
public static void main(String[] args) { String[] cars = {"A", "B", "C", "D"}; List<String> carList = Arrays.asList(cars); for (String car : carList) { System.out.println(car); } }
}
</source>
Convert an array to a Map
<source lang="java">
import java.util.Map; import org.apache.rumons.lang.ArrayUtils; public class Main {
public static void main(String[] args) { String[][] countries = { { "United States", "New York" }, { "United Kingdom", "London" }, { "Netherland", "Amsterdam" }, { "Japan", "Tokyo" }, { "France", "Paris" } }; Map countryCapitals = ArrayUtils.toMap(countries); System.out.println("Capital of Japan is " + countryCapitals.get("Japan")); System.out.println("Capital of France is " + countryCapitals.get("France")); }
}
</source>
Converting a Collection of String to an Array
<source lang="java">
import java.util.ArrayList; import java.util.Collection; public class PlanetSet {
public static void main(String args[]) { String names[] = { "Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune", "Pluto" }; Collection planets = new ArrayList(); for (int i = 0, n = names.length; i < n; i++) { planets.add(names[i]); } String s[] = (String[]) planets.toArray(new String[0]); for (int i = 0, n = s.length; i < n; i++) { System.out.println(s[i]); } planets.remove(names[3]); System.out.println(names[1] + " " + planets.contains(names[1])); System.out.println(names[3] + " " + planets.contains(names[3])); }
}
</source>
Converting a Collection of user objects to an Array
<source lang="java">
import java.util.ArrayList; import java.util.List; public class Main {
public static void main(String[] argv) throws Exception { List list = new ArrayList(); Object[] objectArray = list.toArray(); MyClass[] array = (MyClass[]) list.toArray(new MyClass[list.size()]); }
} class MyClass { }
</source>
Converting an Array to a Collection
<source lang="java">
import java.util.Arrays; import java.util.List; public class Main {
public static void main(String[] argv) throws Exception { int[] array = new int[10]; // Fixed-size list List list = Arrays.asList(array); }
}
</source>
Converts array into a java.util.Map.
<source lang="java">
import java.util.HashMap; import java.util.Map; /*
* Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * * */
/**
* @author Stephen Colebourne * @author Moritz Petersen * @author * @author Maarten Coene * @since 2.0 * @version $Id: ArrayUtils.java 632503 2008-03-01 00:21:52Z ggregory $ */
public class Main {
// To map //----------------------------------------------------------------------- /***
Converts the given array into a {@link java.util.Map}. Each element of the array * must be either a {@link java.util.Map.Entry} or an Array, containing at least two * elements, where the first element is used as key and the second as * value.
**
This method can be used to initialize:
** // Create a Map mapping colors. * Map colorMap = MapUtils.toMap(new String[][] {{ * {"RED", "#FF0000"}, * {"GREEN", "#00FF00"}, * {"BLUE", "#0000FF"}}); *
**
This method returns null
for a null
input array.
* * @param array an array whose elements are either a {@link java.util.Map.Entry} or * an Array containing at least two elements, may benull
* @return aMap
that was created from the array * @throws IllegalArgumentException if one element of this Array is * itself an Array containing less then two elements * @throws IllegalArgumentException if the array contains elements other * than {@link java.util.Map.Entry} and an Array */ public static Map toMap(Object[] array) { if (array == null) { return null; } final Map map = new HashMap((int) (array.length * 1.5)); for (int i = 0; i < array.length; i++) { Object object = array[i]; if (object instanceof Map.Entry) { Map.Entry entry = (Map.Entry) object; map.put(entry.getKey(), entry.getValue()); } else if (object instanceof Object[]) { Object[] entry = (Object[]) object; if (entry.length < 2) { throw new IllegalArgumentException("Array element " + i + ", "" + object + "", has a length less than 2"); } map.put(entry[0], entry[1]); } else { throw new IllegalArgumentException("Array element " + i + ", "" + object + "", is neither of type Map.Entry nor an Array"); } } return map; }
}
</source>
Custom ArrayMap implementation (extends AbstractMap)
<source lang="java">
import java.io.Serializable; import java.util.AbstractMap; import java.util.AbstractSet; import java.util.ArrayList; import java.util.Iterator; import java.util.Map; import java.util.Set; public class ArrayMap extends AbstractMap implements Cloneable, Serializable {
static class Entry implements Map.Entry { protected Object key, value; public Entry(Object key, Object value) { this.key = key; this.value = value; } public Object getKey() { return key; } public Object getValue() { return value; } public Object setValue(Object newValue) { Object oldValue = value; value = newValue; return oldValue; } public boolean equals(Object o) { if (!(o instanceof Map.Entry)) { return false; } Map.Entry e = (Map.Entry) o; return (key == null ? e.getKey() == null : key.equals(e.getKey())) && (value == null ? e.getValue() == null : value.equals(e .getValue())); } public int hashCode() { int keyHash = (key == null ? 0 : key.hashCode()); int valueHash = (value == null ? 0 : value.hashCode()); return keyHash ^ valueHash; } public String toString() { return key + "=" + value; } } private Set entries = null; private ArrayList list; public ArrayMap() { list = new ArrayList(); } public ArrayMap(Map map) { list = new ArrayList(); putAll(map); } public ArrayMap(int initialCapacity) { list = new ArrayList(initialCapacity); } public Set entrySet() { if (entries == null) { entries = new AbstractSet() { public void clear() { list.clear(); } public Iterator iterator() { return list.iterator(); } public int size() { return list.size(); } }; } return entries; } public Object put(Object key, Object value) { int size = list.size(); Entry entry = null; int i; if (key == null) { for (i = 0; i < size; i++) { entry = (Entry) (list.get(i)); if (entry.getKey() == null) { break; } } } else { for (i = 0; i < size; i++) { entry = (Entry) (list.get(i)); if (key.equals(entry.getKey())) { break; } } } Object oldValue = null; if (i < size) { oldValue = entry.getValue(); entry.setValue(value); } else { list.add(new Entry(key, value)); } return oldValue; } public Object clone() { return new ArrayMap(this); } public static void main(String args[]) { Map map = new ArrayMap(13); map.put("1", "One"); map.put("2", "Two"); map.put("3", "Three"); map.put("4", "Four"); map.put("5", "Five"); map.put("6", "Six"); map.put("7", "Seven"); map.put("8", "Eight"); map.put("9", "Nine"); map.put("10", "Ten"); map.put("11", "Eleven"); map.put("12", "Twelve"); map.put("13", "Thirteen"); System.out.println(map); System.out.println(map.keySet()); System.out.println(map.values()); }
}
</source>
Custom ArraySet implementation (extends AbstractSet)
<source lang="java">
import java.io.Serializable; import java.util.AbstractSet; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.Iterator; import java.util.Set; public class ArraySet extends AbstractSet implements Cloneable, Serializable {
private ArrayList list; public ArraySet() { list = new ArrayList(); } public ArraySet(Collection col) { list = new ArrayList(); // No need to check for dups if col is a set Iterator itor = col.iterator(); if (col instanceof Set) { while (itor.hasNext()) { list.add(itor.next()); } } else { while (itor.hasNext()) { add(itor.next()); } } } public Iterator iterator() { return list.iterator(); } public int size() { return list.size(); } public boolean add(Object element) { boolean modified; if (modified = !list.contains(element)) { list.add(element); } return modified; } public boolean remove(Object element) { return list.remove(element); } public boolean isEmpty() { return list.isEmpty(); } public boolean contains(Object element) { return list.contains(element); } public void clear() { list.clear(); } public Object clone() { try { ArraySet newSet = (ArraySet) super.clone(); newSet.list = (ArrayList) list.clone(); return newSet; } catch (CloneNotSupportedException e) { throw new InternalError(); } } public static void main(String args[]) { String elements[] = { "Java", "Source", "and", "Support", "." }; Set set = new ArraySet(Arrays.asList(elements)); Iterator iter = set.iterator(); while (iter.hasNext()) { System.out.println(iter.next()); } }
}
</source>
Remove duplicate element from array
<source lang="java">
import java.util.Arrays; import java.util.HashSet; import java.util.List; import java.util.Set; public class Main {
public static void main(String[] args) { // A string array with duplicate values String[] data = { "A", "C", "B", "D", "A", "B", "E", "D", "B", "C" }; System.out.println("Original array : " + Arrays.toString(data)); List<String> list = Arrays.asList(data); Set<String> set = new HashSet<String>(list); System.out.print("Remove duplicate result: "); String[] result = new String[set.size()]; set.toArray(result); for (String s : result) { System.out.print(s + ", "); } }
}
</source>
Treating an Array as an Enumeration
<source lang="java">
import java.lang.reflect.Array; import java.util.Enumeration; final public class ArrayEnumerationFactory {
static public Enumeration makeEnumeration(final Object obj) { Class type = obj.getClass(); if (!type.isArray()) { throw new IllegalArgumentException(obj.getClass().toString()); } else { return (new Enumeration() { int size = Array.getLength(obj); int cursor; public boolean hasMoreElements() { return (cursor < size); } public Object nextElement() { return Array.get(obj, cursor++); } }); } } public static void main(String args[]) { Enumeration e = makeEnumeration(args); while (e.hasMoreElements()) { System.out.println(e.nextElement()); } e = makeEnumeration(new int[] { 1, 3, 4, 5 }); while (e.hasMoreElements()) { System.out.println(e.nextElement()); } try { e = makeEnumeration(new Double(Math.PI)); } catch (IllegalArgumentException ex) { System.err.println("Can"t enumerate that: " + ex.getMessage()); } }
}
</source>