欧美性猛交XXXX免费看蜜桃,成人网18免费韩国,亚洲国产成人精品区综合,欧美日韩一区二区三区高清不卡,亚洲综合一区二区精品久久

import java.util.*;
            public class ArrayToList
            {
            public static void main(String[] args)
            {
            // This gives us nothing good
            System.out.println(args);
            // Convert args to a List of String
            List<String> argList = Arrays.asList(args);
            // Print them out
            System.out.println(argList);
            }
            }

// Person.java
            import java.util.*;
            public class Person
            implements Iterable<Person>
            {
            public Person(String fn, String ln, int a, Person... kids)
            {
            this.firstName = fn; this.lastName = ln; this.age = a;
            for (Person child : kids)
            children.add(child);
            }
            public String getFirstName() { return this.firstName; }
            public String getLastName() { return this.lastName; }
            public int getAge() { return this.age; }
            public Iterator<Person> iterator() { return children.iterator(); }
            public void setFirstName(String value) { this.firstName = value; }
            public void setLastName(String value) { this.lastName = value; }
            public void setAge(int value) { this.age = value; }
            public String toString() {
            return "[Person: " +
            "firstName=" + firstName + " " +
            "lastName=" + lastName + " " +
            "age=" + age + "]";
            }
            private String firstName;
            private String lastName;
            private int age;
            private List<Person> children = new ArrayList<Person>();
            }
            // App.java
            public class App
            {
            public static void main(String[] args)
            {
            Person ted = new Person("Ted", "Neward", 39,
            new Person("Michael", "Neward", 16），
            new Person("Matthew", "Neward", 10));
            // Iterate over the kids
            for (Person kid : ted)
            {
            System.out.println(kid.getFirstName());
            }
            }
            }
            

public class ReverseIterator
            {
            public static void main(String[] args)
            {
            Person ted = new Person("Ted", "Neward", 39,
            new Person("Michael", "Neward", 16），
            new Person("Matthew", "Neward", 10));
            // Make a copy of the List
            List<Person> kids = new ArrayList<Person>(ted.getChildren());
            // Reverse it
            Collections.reverse(kids);
            // Display it
            System.out.println(kids);
            }
            }

class MyCollections
            {
            public static <T> List<T> reverse(List<T> src)
            {
            List<T> results = new ArrayList<T>(src);
            Collections.reverse(results);
            return results;
            }
            }
            

public interface SortedCollection<E> extends Collection<E>
            {
            public Comparator<E> getComparator();
            public void setComparator(Comparator<E> comp);
            }
            

import java.util.*;
            public class ArraySortedCollection<E>
            implements SortedCollection<E>, Iterable<E>
            {
            private Comparator<E> comparator;
            private ArrayList<E> list;
            public ArraySortedCollection(Comparator<E> c)
            {
            this.list = new ArrayList<E>();
            this.comparator = c;
            }
            public ArraySortedCollection(Collection<? extends E> src, Comparator<E> c)
            {
            this.list = new ArrayList<E>(src);
            this.comparator = c;
            sortThis();
            }
            public Comparator<E> getComparator() { return comparator; }
            public void setComparator(Comparator<E> cmp) { comparator = cmp; sortThis(); }
            public boolean add(E e)
            { boolean r = list.add(e); sortThis(); return r; }
            public boolean addAll(Collection<? extends E> ec)
            { boolean r = list.addAll(ec); sortThis(); return r; }
            public boolean remove(Object o)
            { boolean r = list.remove(o); sortThis(); return r; }
            public boolean removeAll(Collection<?> c)
            { boolean r = list.removeAll(c); sortThis(); return r; }
            public boolean retainAll(Collection<?> ec)
            { boolean r = list.retainAll(ec); sortThis(); return r; }
            public void clear() { list.clear(); }
            public boolean contains(Object o) { return list.contains(o); }
            public boolean containsAll(Collection <?> c) { return list.containsAll(c); }
            public boolean isEmpty() { return list.isEmpty(); }
            public Iterator<E> iterator() { return list.iterator(); }
            public int size() { return list.size(); }
            public Object[] toArray() { return list.toArray(); }
            public <T> T[] toArray(T[] a) { return list.toArray(a); }
            public boolean equals(Object o)
            {
            if (o == this)
            return true;
            if (o instanceof ArraySortedCollection)
            {
            ArraySortedCollection<E> rhs = (ArraySortedCollection<E>)o;
            return this.list.equals(rhs.list);
            }
            return false;
            }
            public int hashCode()
            {
            return list.hashCode();
            }
            public String toString()
            {
            return list.toString();
            }
            private void sortThis()
            {
            Collections.sort(list, comparator);
            }
            }