জাভাতে অর্ডার সেট এর কোন বাস্তবায়ন?

Question 1

যদি কেহ উদ্দেশ্য সি সাথে পরিচিত সেখানে একটি সংগ্রহ বলা হয় NSOrderedSetযে হিসাবে কাজ সেট এবং তার আইটেম একটি হিসাবে অ্যাক্সেস করা যেতে পারে এরে এর বেশী।

জাভাতে কি এরকম কিছু আছে?

শুনেছি সেখানে একটি সংগ্রহ রয়েছে বলা হয়েছে LinkedHashMap, তবে সেটগুলির মতো আমি এর মতো কিছু পাইনি।

Question 2

লিঙ্কডহ্যাশসেট ক্লাসটি একবার দেখুন

জাভা ডক থেকে :

পূর্বাভাসযোগ্য পুনরাবৃত্তির ক্রম সহ হ্যাশ টেবিল এবং সেট ইন্টারফেসের লিঙ্কযুক্ত তালিকা বাস্তবায়ন । এই প্রয়োগটি হ্যাশসেট থেকে পৃথক হয়েছে কারণ এটি তার সমস্ত এন্ট্রি দিয়ে দ্বিগুণ-লিঙ্কযুক্ত তালিকা বজায় রাখে। এই লিঙ্কযুক্ত তালিকাটি পুনরাবৃত্তির ক্রম সংজ্ঞায়িত করে, এটি সেই ক্রম যা উপাদানগুলিকে সেটে প্রবেশ করানো হয়েছিল (সন্নিবেশ-ক্রম) । নোট করুন যে কোনও উপাদানটি যদি সেটে পুনরায় .োকানো হয় তবে সন্নিবেশ ক্রমটি প্রভাবিত হবে না । (একটি উপাদান ই একটি সেটগুলিতে পুনরায় সজ্জিত করা হয় যদি s.add (e) শুরু করা হয় যখন s.contains (e) প্রার্থনার পূর্বে অবিলম্বে সত্য ফিরে আসবে।)

Question 3

প্রতিটি সেটে একটি পুনরাবৃত্তি রয়েছে ()। একটি স্বাভাবিক HashSet পুনরুক্তিকারীর বেশ র্যান্ডম একটি TreeSet সাজানোর ক্রম, একটি দ্বারা এটা আছে যে, LinkedHashSet পুনরুক্তিকারীর সন্নিবেশ আদেশ দ্বারা iterates।

তবে আপনি কোনও লিঙ্কডহ্যাশসেটে কোনও উপাদান প্রতিস্থাপন করতে পারবেন না। আপনি একটি মুছে ফেলতে এবং অন্যটিকে যুক্ত করতে পারেন, তবে নতুন উপাদানটি আসল জায়গায় থাকবে না। লিংকডহ্যাশম্যাপে আপনি বিদ্যমান কীটির জন্য একটি মান প্রতিস্থাপন করতে পারেন এবং তারপরে মানগুলি মূল ক্রমে থাকবে।

এছাড়াও, আপনি একটি নির্দিষ্ট অবস্থানে সন্নিবেশ করতে পারবেন না।

সদৃশ avoidোকানো এড়াতে আপনি একটি সুস্পষ্ট চেক সহ আরও একটি অ্যারেলিস্ট ব্যবহার করতে পারেন।

Question 4

কটাক্ষপাত জাভা মান এপিআই ডক । ঠিক পাশেই LinkedHashMap, একটি আছে LinkedHashSet। তবে মনে রাখবেন যে সেগুলিতে ক্রমটি সন্নিবেশ আদেশ, উপাদানগুলির প্রাকৃতিক ক্রম নয়। এবং আপনি কেবল সেই ক্রমে পুনরাবৃত্তি করতে পারেন, এলোমেলো অ্যাক্সেস করবেন না (পুনরাবৃত্তির পদক্ষেপ গণনা ব্যতীত)।

এছাড়া একটি ইন্টারফেস SortedSetদ্বারা বাস্তবায়িত TreeSetএবং ConcurrentSkipListSet। উভয়ই তাদের উপাদানগুলির প্রাকৃতিক ক্রমে পুনরাবৃত্তির অনুমতি দেয় বা এ Comparator, তবে এলোমেলো অ্যাক্সেস বা সন্নিবেশ ক্রমের নয়।

এমন একটি ডেটা স্ট্রাকচারের জন্য যা উভয় সূচকে দক্ষ অ্যাক্সেস পেয়েছে এবং সেটটি মানদণ্ডকে দক্ষতার সাথে প্রয়োগ করতে পারে, আপনার এড়িয়ে যাওয়ার একটি তালিকা দরকার , তবে জাভা স্ট্যান্ডার্ড এপিআইতে সেই কার্যকারিতা সহ কোনও প্রয়োগ করা হয়নি, যদিও আমি নিশ্চিত যে এটির সন্ধান করা সহজ though ইন্টারনেটে.

Question 5

java.util.TreeSetযে সরঞ্জাম ব্যবহার করে দেখুন SortedSet।

দস্তাবেজের উদ্ধৃতি দিতে:

"উপাদানগুলি তাদের প্রাকৃতিক ক্রম ব্যবহার করে বা সেট তৈরির সময় সরবরাহকারী কোনও তুলনাকারীর দ্বারা আদেশ করা হয় যা নির্মাতা ব্যবহার করা হচ্ছে তার উপর নির্ভর করে"

নোট করুন যে যোগ করুন, সরান এবং এর একটি সময় ব্যয় লগ আছে (এন)।

আপনি যদি অ্যারের হিসাবে সেটটির সামগ্রীটি অ্যাক্সেস করতে চান তবে আপনি এটি করে রূপান্তর করতে পারেন:

YourType[] array = someSet.toArray(new YourType[yourSet.size()]);

এই অ্যারেটি ট্রিসেটের মতো একই মানদণ্ড অনুসারে বাছাই করা হবে (প্রাকৃতিক বা তুলনাকারী) এবং অনেক ক্ষেত্রে এটি অ্যারে করার পরিবর্তে একটি সুবিধা পাবে ort

Question 6

TreeSet আদেশ করা হয়।

http://docs.oracle.com/javase/6/docs/api/java/util/TreeSet.html

Question 7

ট্রিসেট হ'ল অর্ডারযুক্ত সেট, তবে আপনি কোনও আইটেম সূচকের মাধ্যমে অ্যাক্সেস করতে পারবেন না, কেবল পুনরাবৃত্তি করুন বা শুরু / শেষ দিকে যেতে পারেন।

Question 8

যদি আমরা স্কিপ-লিস্টের সস্তা ব্যয়ের বাস্তবায়ন সম্পর্কে কথা বলি, আমি বিগ ও এর শর্তে অবাক হই, এই অপারেশনটির ব্যয়টি কী:

আপনার টাইপ [] অ্যারে = someSet.toArray (নতুন আপনার টাইপ [আপনারসেট.সাইজ ()]);

আমি বলতে চাইছি এটি সর্বদা পুরো অ্যারে সৃষ্টিতে আটকে থাকে তাই এটি ও (এন):

java.util.Arrays#copyOf

Question 9

IndexedTreeSet থেকে সূচীবদ্ধ-ট্রি-মানচিত্র (মত তালিকা সূচক মাধ্যমে অ্যাক্সেসের আদেশ / সাথে সেট সাজানো হিসেবে) প্রকল্পের এই কার্যকারিতা প্রদান করে।

Question 10

গুগল পেয়ারা BiMap থেকে প্রাপ্ত বিডিরেশনাল মানচিত্রের থেকে আপনি কিছু উপযোগিতাও পেতে পারেন

একটি দিয়ে BiMap, আপনি খুব দক্ষতার সাথে অন্য কোনও অবজেক্টের ধরণের (র্যান্ডম সূচক অ্যাক্সেসের জন্য) পূর্ণসংখ্যার মানচিত্র তৈরি করতে পারেন। BiMapগুলি ওয়ান-টু-ওয়ান, সুতরাং যে কোনও প্রদত্ত পূর্ণসংখ্যার সাথে এটির সাথে সর্বাধিক একটি উপাদান যুক্ত থাকে এবং যে কোনও উপাদানটির একটিতে পূর্ণসংখ্যা থাকে। এটি চতুরতার সাথে দুটি HashTableদৃষ্টান্তের সাহায্যে তৈরি করা হয়েছে, সুতরাং এটি প্রায় দ্বিগুণ স্মৃতি ব্যবহার করে, তবে এটি Listপ্রক্রিয়াজাতকরণের তুলনায় অনেক বেশি কার্যকর কারণ contains()(যা কোনও আইটেম ইতিমধ্যে উপস্থিত রয়েছে কিনা তা পরীক্ষা করার জন্য যুক্ত করা হয়) একটি ধ্রুবক সময় এবং সমান্তরাল বান্ধব অপারেশনগুলির মতো HashSet, যখন Listএর বাস্তবায়ন অনেক ধীর।

Question 11

আমারও একই সমস্যা ছিল। আমার বেশিরভাগ অর্ডার করা সেট নয় তবে দ্রুত indexOf/ সঙ্গে আরও একটি তালিকার দরকার ছিল contains। আমি সেখানে কিছুই খুঁজে না পেয়ে আমি নিজেই একটি প্রয়োগ করেছিলাম। কোডটি এখানে, এটি উভয়ই প্রয়োগ করে Setএবং Listযদিও সমস্ত বাল্ক তালিকার ক্রিয়াকলাপগুলি ArrayListসংস্করণগুলির চেয়ে তত দ্রুত নয় ।

অস্বীকৃতি: পরীক্ষিত নয়

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;
import java.util.Collection;
import java.util.Comparator;
import java.util.function.Predicate;
import java.util.function.UnaryOperator;
import static java.util.Objects.requireNonNull;

/**
 * An ArrayList that keeps an index of its content so that contains()/indexOf() are fast. Duplicate entries are
 * ignored as most other java Set's do.
 */
public class IndexedArraySet<E> extends ArrayList<E> implements Set<E> {

    public IndexedArraySet() { super(); }

    public IndexedArraySet(Iterable<E> c) {
        super();
        addAll(c);
    }

    private HashMap<E, Integer> indexMap = new HashMap<>();

    private void reindex() {
        indexMap.clear();
        int idx = 0;
        for (E item: this) {
            addToIndex(item, idx++);
        }
    }

    private E addToIndex(E e, int idx) {
        indexMap.putIfAbsent(requireNonNull(e), idx);
        return e;
    }

    @Override
    public boolean add(E e) {
        if(indexMap.putIfAbsent(requireNonNull(e), size()) != null) return false;
        super.add(e);
        return true;
    }

    @Override
    public boolean addAll(Collection<? extends E> c) {
        return addAll((Iterable<? extends E>) c);
    }
    public boolean addAll(Iterable<? extends E> c) {
        boolean rv = false;
        for (E item: c) {
            rv |= add(item);
        }
        return rv;
    }

    @Override
    public boolean contains(Object e) {
        return indexMap.containsKey(e);
    }

    @Override

    public int indexOf(Object e) {
        if (e == null) return -1;
        Integer i = indexMap.get(e);
        return (i == null) ? -1 : i;
    }

    @Override
    public int lastIndexOf(Object e) {
        return indexOf(e);
    }

    @Override @SuppressWarnings("unchecked")
    public Object clone() {
        IndexedArraySet clone = (IndexedArraySet) super.clone();
        clone.indexMap = (HashMap) indexMap.clone();
        return clone;
    }

    @Override
    public void add(int idx, E e) {
        if(indexMap.putIfAbsent(requireNonNull(e), -1) != null) return;
        super.add(idx, e);
        reindex();
    }

    @Override
    public boolean remove(Object e) {
        boolean rv;
        try { rv = super.remove(e); }
        finally { reindex(); }
        return rv;
    }

    @Override
    public void clear() {
        super.clear();
        indexMap.clear();
    }

    @Override
    public boolean addAll(int idx, Collection<? extends E> c) {
        boolean rv;
        try {
            for(E item : c) {
                // check uniqueness
                addToIndex(item, -1);
            }
            rv = super.addAll(idx, c);
        } finally {
            reindex();
        }
        return rv;
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        boolean rv;
        try { rv = super.removeAll(c); }
        finally { reindex(); }
        return rv;
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        boolean rv;
        try { rv = super.retainAll(c); }
        finally { reindex(); }
        return rv;
    }

    @Override
    public boolean removeIf(Predicate<? super E> filter) {
        boolean rv;
        try { rv = super.removeIf(filter); }
        finally { reindex(); }
        return rv;
    }

    @Override
    public void replaceAll(final UnaryOperator<E> operator) {
        indexMap.clear();
        try {
            int duplicates = 0;
            for (int i = 0; i < size(); i++) {
                E newval = requireNonNull(operator.apply(this.get(i)));
                if(indexMap.putIfAbsent(newval, i-duplicates) == null) {
                    super.set(i-duplicates, newval);
                } else {
                    duplicates++;
                }
            }
            removeRange(size()-duplicates, size());
        } catch (Exception ex) {
            // If there's an exception the indexMap will be inconsistent
            reindex();
            throw ex;
        }

    }

    @Override
    public void sort(Comparator<? super E> c) {
        try { super.sort(c); }
        finally { reindex(); }
    }
}