C# HashedSet.Union方法代码示例

        public static void Main()
        {
            var firstSet = new HashedSet<string>();
            var secondSet = new HashedSet<string>();

            firstSet.Add("Pesho");
            firstSet.Add("Gosho");
            firstSet.Add("Tosho");

            secondSet.Add("Ivan");
            secondSet.Add("Petkan");
            secondSet.Add("Dragan");

            Console.WriteLine(firstSet);
            Console.WriteLine(secondSet);

            Console.WriteLine(firstSet.Intersect(secondSet));
            Console.WriteLine(secondSet.Intersect(firstSet));

            Console.WriteLine(firstSet.Union(secondSet));
            Console.WriteLine(secondSet.Union(firstSet));

            firstSet.Remove("Pesho");
            firstSet.Remove("Tosho");
            Console.WriteLine(firstSet);

            Console.WriteLine(firstSet.Find("Tosho"));
            Console.WriteLine(firstSet.Find("Gosho"));

            Console.WriteLine(firstSet.Count);
        }

        public void Union_Test()
        {
            HashedSet<int> set = new HashedSet<int>();
            HashedSet<int> otherSet = new HashedSet<int>();

            set.Add(1);
            set.Add(2);
            set.Add(3);

            otherSet.Add(3);
            otherSet.Add(4);
            otherSet.Add(5);

            set.Union(otherSet);

            StringBuilder actual = new StringBuilder();
            foreach (var item in set)
            {
                actual.Append(item + " ");
            }

            string expected = "1 2 3 4 5 ";

            Assert.AreEqual(expected, actual.ToString());
        }

    public static void Main()
    {
        HashedSet<float> firstSet = new HashedSet<float>();
        firstSet.Add(1f);
        firstSet.Add(1.4f);
        firstSet.Add(1.7f);
        firstSet.Add(2f);
        firstSet.Add(2.2f);
        firstSet.Remove(1.7f);
        Console.WriteLine(firstSet.Find(1f));
        Console.WriteLine(firstSet.Count);

        HashedSet<float> secondSet = new HashedSet<float>();
        secondSet.Add(1f);
        secondSet.Add(2f);
        secondSet.Add(3f);
        secondSet.Add(5f);

        HashedSet<float> thirdSet = new HashedSet<float>();
        thirdSet.Add(1f);
        thirdSet.Add(2f);
        thirdSet.Add(3f);
        thirdSet.Add(5f);

        secondSet.Union(firstSet);
        thirdSet.Intersect(firstSet);
        firstSet.Clear();
    }

        public static void Main(string[] args)
        {
            HashedSet<string> students = new HashedSet<string>();
            students.Add("Pesho");
            students.Add("Pesho");
            students.Add("Gosho");
            students.Remove("Gosho");
            students.Add("Misho");
            students.Add("Ivan");
            Console.WriteLine("Student count: {0}", students.Count);

            HashedSet<string> users = new HashedSet<string>();
            users.Add("Mariq");
            users.Add("Pesho");
            users.Add("Misho");

            HashedSet<string> intersection = students.Intersect(users);
            Console.WriteLine("Intersection:");
            foreach (var name in intersection)
            {
                Console.WriteLine(name);
            }

            HashedSet<string> union = students.Union(users);
            Console.WriteLine("Union: ");
            foreach (var name in union)
            {
                Console.WriteLine(name);
            }
        }

        public void HashedSetUnionTestSameElementsInBoth()
        {
            HashedSet<int> firstSet = new HashedSet<int>();
            int firstSetLength = 5;
            for (int i = 0; i < firstSetLength; i++)
            {
                firstSet.Add(i);
            }

            HashedSet<int> secondSet = new HashedSet<int>();
            int secondSetLength = 5;
            for (int i = 0; i < secondSetLength; i++)
            {
                secondSet.Add(i);
            }

            Assert.AreEqual(firstSetLength, firstSet.Count, "Incorrect set count!");
            Assert.AreEqual(secondSetLength, secondSet.Count, "Incorrect set count!");

            firstSet.Union(secondSet);

            for (int i = 0; i < firstSetLength; i++)
            {
                Assert.IsTrue(firstSet.Contains(i), "Incorrect union!");
            }

            Assert.AreEqual(firstSetLength, firstSet.Count, "Incorrect amount of elements after union");
        }

        public static void Main()
        {
            var set = new HashedSet<int>();

            for (int i = 1; i < 11; i++)
            {
                for (int j = 0; j < 3; j++)
                {
                    set.Add(i);
                }
            }

            System.Console.WriteLine(set);
            System.Console.WriteLine(set.Count);

            var otherSet = new HashedSet<int>();

            for (int i = 5; i < 16; i++)
            {
                otherSet.Add(i);
            }

            System.Console.WriteLine(otherSet);
            System.Console.WriteLine(otherSet.Count);
            System.Console.WriteLine(set.IntersectsWith(otherSet));
            System.Console.WriteLine(set.Union(otherSet));
        }

        static void Main()
        {
            HashedSet<string> myBestFriends = new HashedSet<string>();

            myBestFriends.Add("Ivan");
            myBestFriends.Add("Daniel");
            myBestFriends.Add("Cecilia");

            Console.WriteLine(myBestFriends.Count);

            myBestFriends.Remove("Cecilia");
            Console.WriteLine(myBestFriends.Count);

            HashedSet<string> yourBestFriends = new HashedSet<string>();

            yourBestFriends.Add("Petar");
            yourBestFriends.Add("Daniel");
            yourBestFriends.Add("Monika");

            HashedSet<string> allBestFriends = myBestFriends.Union(yourBestFriends);

            Console.WriteLine("All best friends: ");
            foreach (var item in allBestFriends.setOfData)
            {
                Console.WriteLine("{0}", item.Value);
            }

            HashedSet<string> mutualBestFriends = myBestFriends.Intersect(yourBestFriends);

            Console.WriteLine("Mutual best friends: ");
            foreach (var item in mutualBestFriends.setOfData)
            {
                Console.WriteLine("{0}", item.Value);
            }
        }

        static void Main()
        {
            var mySet = new HashedSet<string>();
            mySet.Add("string");
            mySet.Add("str");
            //mySet.Add(null);
            mySet.Add("strength");
            mySet.Add("string");

            //var strength = mySet.Find("strength");
            //Console.WriteLine(strength);

            //var isStringRemoved = mySet.Remove("string");
            //Console.WriteLine(isStringRemoved);

            var mySecondSet = new HashedSet<string>();
            mySecondSet.Add("strength");
            mySecondSet.Add("dexterity");
            mySecondSet.Add("intelligence");

            mySet.Union(mySecondSet);
            //mySet.Intersect(mySecondSet);
            foreach (var item in mySet)
            {
                Console.WriteLine(item);
            }
        }

        static void Main()
        {
            var set = new HashedSet<int>();

            set.Add(5);
            set.Add(3);
            set.Add(-4);
            set.Add(12);
            set.Add(0);
            set.Add(-50);
            set.Add(10);
            Console.WriteLine("Set contains 12 -> {0}", set.Find(12));
            Console.WriteLine("Set contains 13 -> {0}", set.Find(13));
            set.Remove(10);
            Console.WriteLine("Removed 10\nSet contains 10 -> {0}", set.Find(10));
            Console.WriteLine("Set contains {0} items", set.Count);
            Console.WriteLine("Set 1: {0}", set);

            var anotherSet = new HashedSet<int>();
            anotherSet.Add(-4);
            anotherSet.Add(15);
            anotherSet.Add(0);
            anotherSet.Add(-122);
            anotherSet.Add(35);
            Console.WriteLine("Set 2: {0}", anotherSet);

            set.Union(anotherSet);
            Console.WriteLine("Set after union: {0}", set);

            set.Intersect(anotherSet);
            Console.WriteLine("Set after intersect: {0}", set);

            set.Clear();
            Console.WriteLine("Set contains {0} items after clear", set.Count);
        }

        public void ShouldReturnCorrectUnion()
        {
            var set = new HashedSet<int>();
            set.Add(1);
            set.Add(2);
            var otherSet = new HashedSet<int>();
            otherSet.Add(2);
            otherSet.Add(3);

            CollectionAssert.AreEqual(new[] { 1, 2, 3 }, set.Union(otherSet));
        }

        public static void Main(string[] args)
        {
            var hashedSet1 = new HashedSet<string>();

            for (int i = 0; i < 4; i++)
            {
                hashedSet1.Add("pesho" + i);
            }

            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.WriteLine("First hashed set:");
            foreach (var item in hashedSet1)
            {
                 Console.WriteLine(item);
            }

            var hashedSet2 = new HashedSet<string>();

            for (int i = 2; i < 6; i++)
            {
                hashedSet2.Add("pesho" + i);
            }

            Console.ForegroundColor = ConsoleColor.Cyan;
            Console.WriteLine("\nSecond hashed set:");
            foreach (var item in hashedSet2)
            {
                Console.WriteLine(item);
            }


            var intersected = hashedSet1.Intersect(hashedSet2);

            Console.ForegroundColor = ConsoleColor.White;
            Console.WriteLine("\nIntersected:");
            foreach (var item in intersected)
            {
                Console.WriteLine(item);
            }

            var unioned = hashedSet1.Union(hashedSet2);

            Console.ForegroundColor = ConsoleColor.Green;
            Console.WriteLine("\nUnioned:");
            foreach (var item in unioned)
            {
                Console.WriteLine(item);
            }
        }

        public static void Main()
        {
            HashedSet<string> hashedSet = new HashedSet<string>();
            for (int i = 0; i < 5; i++)
            {
                hashedSet.Add("item " + i);
            }

            var set = new List<string> { "item 3", "item 5" };
            var unionSet = hashedSet.Union(set);
            var intersectSet = hashedSet.Intersect(set);

            Console.WriteLine("Union: {0}", string.Join(", ", unionSet));
            Console.WriteLine("Intersect: {0}", string.Join(", ", intersectSet));
        }

 internal static void Main()
 {
     HashedSet<int> test = new HashedSet<int>();
     HashedSet<int> other = new HashedSet<int>();
     test.Add(1);
     test.Add(2);
     test.Add(3);
     test.Add(4);
     test.Add(5);
     test.Add(6);
     other.Add(4);
     other.Add(5);
     other.Add(6);
     other.Add(7);
     other.Add(8);
     Console.WriteLine("Initial hash set:");
     Console.WriteLine(string.Join(", ", test));
     Console.WriteLine("--------------------------------------------------------------");
     Console.WriteLine("After removal of 3:");
     test.Remove(3);
     Console.WriteLine(string.Join(", ", test));
     Console.WriteLine("--------------------------------------------------------------");
     Console.WriteLine("Is 1 found? {0}", test.Find(1));
     Console.WriteLine("Is 3 found? {0}", test.Find(3));
     Console.WriteLine("--------------------------------------------------------------");
     Console.WriteLine("First hash set:");
     Console.WriteLine(string.Join(", ", test));
     Console.WriteLine("Member count: {0}", test.Count);
     Console.WriteLine("--------------------------------------------------------------");
     Console.WriteLine("Second hash set:");
     Console.WriteLine(string.Join(", ", other));
     Console.WriteLine("Member count: {0}", other.Count);
     Console.WriteLine("--------------------------------------------------------------");
     Console.WriteLine("Intersect of the first and second:");
     Console.WriteLine(string.Join(", ", test.Intersect(other)));
     Console.WriteLine("--------------------------------------------------------------");
     Console.WriteLine("Union of the first and second:");
     Console.WriteLine(string.Join(", ", test.Union(other)));
     Console.WriteLine("--------------------------------------------------------------");
     test.Clear();
     Console.WriteLine("First hash set after clear:");
     Console.WriteLine(string.Join(", ", test));
 }

        static void Main()
        {
            HashedSet<int> hSet = new HashedSet<int>();

            hSet.Add(5);
            hSet.Add(15);
            hSet.Add(5);

            Console.WriteLine(hSet.Find(45));
            Console.WriteLine(hSet.Find(15));
            hSet.Remove(5);
            Console.WriteLine(hSet.Find(5));

            hSet.Clear();

            Console.WriteLine(hSet.Count);

            hSet.Add(5);
            hSet.Add(15);
            hSet.Add(25);
            hSet.Add(35);

            HashedSet<int> hSetTwo = new HashedSet<int>();
            hSetTwo.Add(4);
            hSetTwo.Add(24);
            hSetTwo.Add(25);
            hSetTwo.Add(35);

            var newIntersectedSet = hSet.Intersect(hSetTwo);

            foreach (var item in newIntersectedSet.Keys)
            {
                Console.WriteLine(item);
            }

            var newUnitedSet = hSet.Union(hSetTwo);

            foreach (var item in newUnitedSet.Keys)
            {
                Console.WriteLine(item);
            }
        }

    /* Task 5: 
     * Implement the data structure "set" in a class HashedSet<T> using your class HashTable<K,T>
     * to hold the elements. Implement all standard set operations like Add(T), Find(T), Remove(T),
     * Count, Clear(), union and intersect.
     */

    static void Main(string[] args)
    {
        var setOne = new HashedSet<int>();

        for (int i = 0; i < 50; i++)
        {
            setOne.Add(i);
        }

        Console.WriteLine(setOne.Count());

        for (int i = 25; i < 50; i++)
        {
            setOne.Remove(i);
        }

        Console.WriteLine(setOne.Count());

        var setTwo = new HashedSet<int>();

        setTwo.Add(100);
        setTwo.Add(101);
        setTwo.Add(102);
        setTwo.Add(103);
        setTwo.Add(104);
        setTwo.Add(105);

        //Saving all results from Union
        setOne = setOne.Union(setTwo);
        Console.WriteLine(setOne.Count());

        setTwo.Clear();
        for (int i = 10; i < 25; i++)
        {
            setTwo.Add(i);
        }

        //Saving only the intersect Results
        setOne = setOne.Intersect(setTwo);
        Console.WriteLine(setOne.Count());
    }