algorithms.java

java 的源代码

package com.reddragon2046.base.utilities.data.adapters;

import com.reddragon2046.base.utilities.data.*;
import java.util.Collection;
import java.util.Iterator;

final class Algorithms
{
    static final class Filling
    {

        public static void fill(ForwardIterator first, ForwardIterator last, Object object)
        {
            for(; !first.equals(last); first.advance())
                first.put(object);

        }

        private Filling()
        {
        }
    }

    static final class Copying
    {

        public static OutputIterator copy(ForwardIterator first, ForwardIterator last, OutputIterator result)
        {
            ForwardIterator firstx = (ForwardIterator)first.clone();
            OutputIterator resultx = (OutputIterator)result.clone();
            for(; !firstx.equals(last); resultx.advance())
                resultx.put(firstx.next());

            return resultx;
        }

        public static void copyBackward(BidirectionalIterator first, BidirectionalIterator last, BidirectionalIterator result)
        {
            BidirectionalIterator lastx = (BidirectionalIterator)last.clone();
            BidirectionalIterator resultx = (BidirectionalIterator)result.clone();
            for(; !first.equals(lastx); resultx.put(lastx.get()))
            {
                resultx.retreat();
                lastx.retreat();
            }

        }

        private Copying()
        {
        }
    }

    static final class Counting
    {

        public static int count(InputIterator first, InputIterator last, Object object)
        {
            InputIterator firstx = (InputIterator)first.clone();
            int n = 0;
            while(!firstx.equals(last))
                if(firstx.next().equals(object))
                    n++;
            return n;
        }

        private Counting()
        {
        }
    }

    static final class Replacing
    {

        public static int replace(ForwardIterator first, ForwardIterator last, Object oldValue, Object newValue)
        {
            ForwardIterator firstx = (ForwardIterator)first.clone();
            int n = 0;
            for(; !firstx.equals(last); firstx.advance())
                if(firstx.get().equals(oldValue))
                {
                    firstx.put(newValue);
                    n++;
                }

            return n;
        }

        private Replacing()
        {
        }
    }

    static final class Finding
    {

        public static InputIterator find(InputIterator first, InputIterator last, Object object)
        {
            InputIterator firstx;
            for(firstx = (InputIterator)first.clone(); !firstx.equals(last) && !firstx.get().equals(object); firstx.advance());
            return firstx;
        }

        private Finding()
        {
        }
    }

    static final class Removing
    {

        public static ForwardIterator remove(ForwardIterator first, ForwardIterator last, Object object)
        {
            first = (ForwardIterator)Finding.find(first, last, object);
            if(first.equals(last))
                return first;
            ForwardIterator i = (ForwardIterator)first.clone();
            i.advance();
            for(; !i.equals(last); i.advance())
                if(!i.get().equals(object))
                {
                    first.put(i.get());
                    first.advance();
                }

            return first;
        }

        private Removing()
        {
        }
    }

    static final class Comparing
    {

        public static boolean equal(Container container1, Container container2)
        {
            if(container1.size() != container2.size())
                return false;
            Iterator iter1 = container1.start();
            Iterator iter2 = container2.start();
            while(iter1.hasNext())
                if(!iter1.next().equals(iter2.next()))
                    return false;
            return true;
        }

        private Comparing()
        {
        }
    }

    static final class Hashing
    {

        public static int orderedHash(ForwardIterator iter, int length)
        {
            int h = 0;
            int position = 0;
            int skip = 1;
            if(length >= 16)
            {
                skip = length / 16;
                iter.advance(length % 16);
            }
            for(; iter.hasNext(); iter.advance(skip))
            {
                if(iter.get() != null)
                    h ^= iter.get().hashCode() / (position % 16 + 1);
                position++;
            }

            return h;
        }

        public static int unorderedHash(ForwardIterator iter)
        {
            int h = 0;
            for(; iter.hasNext(); iter.advance())
                if(iter.get() != null)
                    h ^= iter.get().hashCode();

            return h;
        }

        static final int HASH_SIZE = 16;

        private Hashing()
        {
        }
    }

    static final class Printing
    {

        public static String toString(Container container, String name)
        {
            StringBuffer buffer = new StringBuffer(name);
            buffer.append("(");
            boolean first = true;
            for(Iterator iter = container.start(); iter.hasNext(); buffer.append(iter.next()))
                if(first)
                {
                    buffer.append(" ");
                    first = false;
                } else
                {
                    buffer.append(", ");
                }

            if(first)
                buffer.append(")");
            else
                buffer.append(" )");
            return buffer.toString();
        }

        private Printing()
        {
        }
    }


    private Algorithms()
    {
    }
}