蓝桥杯练习6

蓝桥杯练习题：不同子串

做这道题时发现简单的数组遍历并不能完成，必须要是不同的非空字串，数组遍历的方式过于麻烦。

思路：
1.关于字串：0100110001010001   则要用set集合去重。则必须用String.substring()方法求子串规律为一开始子串长度.
2.set集合下有两大实现类：HashSet，以及TreeSet
3.由于set是一个集合，规定一个存储String类型的集合，遍历这个子串。利用HashSet添加将这个子串以不同数量级进行遍历，然后存储到该集合中。
4.利用HashSet中hashset.size()方法求出该集合的容量大小。

代码展示如下：

package 第十届蓝桥杯大赛决赛题;

import java.util.HashSet;
import java.util.Set;

public class 不同子串 {
//不同的非空子串，则会用set集合去重，String.substring()方法求子串规律为一开始子串长度
//为一，二，……以此类推
	public static void main(String[] args) {
		String str="0100110001010001";
		//创建一个集合存储这个子串
		Set<String> sub=new HashSet<String>();
		//遍历这个子串
		for(int step=0;step<=str.length()-1;step++) {
		//以不同的数量级形式进行遍历存储
			for(int beginIndex=0,endIndex=1+step;endIndex<=str.length();beginIndex++,endIndex++) {
			//利用Hashset集合的添加元素add()方法
				sub.add(str.substring(beginIndex,endIndex));
			}
		}
		System.out.println(sub.size());
	}
}

最终结果为：100

由于这道题涉及到我的知识盲区，所以我又重新学习了java集合方面的知识点。

1.Set集合

1.Set继承于Collection接口，是一个不允许出现重复元素，并且无序的集合，主要有HashSet和TreeSet两大实现类。

2.在判断重复元素的时候，Set集合会调用hashCode()和equal()方法来实现。

3.HashSet是哈希表结构，主要利用HashMap的key来存储元素，计算插入元素的hashCode来获取元素在集合中的位置；

4.TreeSet是红黑树结构，每一个元素都是树中的一个节点，插入的元素都会进行排序；

1.1Set常用方法

public interface Set<E> extends Collection<E> {
//继承collection集合类
    A:添加功能
    boolean add(E e);
    boolean addAll(Collection<? extends E> c);

    B:删除功能
    boolean remove(Object o);
    boolean removeAll(Collection<?> c);//删除所有
    void clear();

    C:长度功能
    int size();

    D:判断功能
    boolean isEmpty();
    boolean contains(Object o);
    boolean containsAll(Collection<?> c);
    boolean retainAll(Collection<?> c); 

    E:获取Set集合的迭代器：
    Iterator<E> iterator();

    F:把集合转换成数组
    Object[] toArray();
    <T> T[] toArray(T[] a);
    
    //判断元素是否重复，为子类提高重写方法
    boolean equals(Object o);
    int hashCode();
}

1.2HashSet

当有元素插入的时候，会计算元素的hashCode值，将元素插入到哈希表对应的位置中来；
它继承于AbstractSet，实现了Set, Cloneable, Serializable接口。

转载过来的：

(1)HashSet继承AbstractSet类，获得了Set接口大部分的实现，减少了实现此接口所需的工作，实际上是又继承了AbstractCollection类；

(2)HashSet实现了Set接口，获取Set接口的方法，可以自定义具体实现，也可以继承AbstractSet类中的实现；

(3)HashSet实现Cloneable，得到了clone()方法，可以实现克隆功能；

(4)HashSet实现Serializable，表示可以被序列化，通过序列化去传输，典型的应用就是hessian协议。

HashSet集合有以下特点：
1.不允许出现重复元素
2.允许插入Null值
3.元素无序（添加顺序和遍历顺序不一致）
4.线程不安全，若两个线程同时操作HashSet，必须通过代码实现同步。

接下来是HashSet基本操作：

1.3HashSet基本操作

由于Set集合中并没有角标的概念，所以并没有像List一样提供get（）方法。
当获取HashSet中某个元素时，只能通过遍历集合的方式进行equals()比较来实现；

代码展示如下：

public class HashSetTest {
    public static void main(String[] agrs){
        //创建HashSet集合：
        Set<String> hashSet = new HashSet<String>();
        System.out.println("HashSet初始容量大小："+hashSet.size());

        //元素添加：
        hashSet.add("my");
        hashSet.add("name");
        hashSet.add("is");
        hashSet.add("jiaboyan");
        hashSet.add(",");
        hashSet.add("hello");
        hashSet.add("world");
        hashSet.add("!");
        System.out.println("HashSet容量大小："+hashSet.size());

        //迭代器遍历：
        Iterator<String> iterator = hashSet.iterator();
        while (iterator.hasNext()){
            String str = iterator.next();
            System.out.println(str);
        }
        //增强for循环
        for(String str:hashSet){
            if("jiaboyan".equals(str)){
                System.out.println("你就是我想要的元素:"+str);
            }
            System.out.println(str);
        }

        //元素删除：
        hashSet.remove("jiaboyan");
        System.out.println("HashSet元素大小：" + hashSet.size());
        hashSet.clear();
        System.out.println("HashSet元素大小：" + hashSet.size());

        //集合判断：
        boolean isEmpty = hashSet.isEmpty();
        System.out.println("HashSet是否为空：" + isEmpty);
        boolean isContains = hashSet.contains("hello");
        System.out.println("HashSet是否为空：" + isContains);
    }
}

我只学习了HashSet集合有关基本操作以及概念。具体知识没有进行深究。

1.4TreeSet

1.与HashSet不同的是，TreeSet具有排序功能，分为自然排序(123456)和自定义排序两类，默认是自然排序；
2.在程序中，我们可以按照任意顺序将元素插入到集合中，等到遍历时TreeSet会按照一定顺序输出--倒序或者升序；
3.它继承AbstractSet，实现NavigableSet（实现该接口使得TreeSet具备了元素搜索功能）, Cloneable, Serializable接口。

具有如下特点：
1.对插入的元素进行排序，是一个有序的集合（主要与HashSet的区别）

2.底层使用红黑树结构，而不是哈希表结构

3.允许插入Null值

4.不允许插入重复元素。

1.5TreeSet基本操作

public class TreeSetTest {
    public static void main(String[] agrs){
        TreeSet<String> treeSet = new TreeSet<String>();
        System.out.println("TreeSet初始化容量大小："+treeSet.size());

        //元素添加：
        treeSet.add("my");
        treeSet.add("name");
        treeSet.add("jiaboyan");
        treeSet.add("hello");
        treeSet.add("world");
        treeSet.add("1");
        treeSet.add("2");
        treeSet.add("3");
        System.out.println("TreeSet容量大小：" + treeSet.size());
        System.out.println("TreeSet元素顺序为：" + treeSet.toString());

        //增加for循环遍历：
        for(String str:treeSet){
            System.out.println("遍历元素："+str);
        }

        //迭代器遍历：升序  
        Iterator<String> iteratorAesc = treeSet.iterator();
        while(iteratorAesc.hasNext()){
            String str = iteratorAesc.next();
            System.out.println("遍历元素升序："+str);
        }

        //迭代器遍历：降序
        Iterator<String> iteratorDesc = treeSet.descendingIterator();
        while(iteratorDesc.hasNext()){
            String str = iteratorDesc.next();
            System.out.println("遍历元素降序："+str);
        }

        //元素获取:实现NavigableSet接口
        String firstEle = treeSet.first();//获取TreeSet头节点：
        System.out.println("TreeSet头节点为：" + firstEle);

        // 获取指定元素之前的所有元素集合：(不包含指定元素)
        SortedSet<String> headSet = treeSet.headSet("jiaboyan");
        System.out.println("jiaboyan节点之前的元素为："+headSet.toString());

        //获取给定元素之间的集合：（包含头，不包含尾）
        SortedSet subSet = treeSet.subSet("1","world");
        System.out.println("1--jiaboan之间节点元素为："+subSet.toString());

        //集合判断：
        boolean isEmpty = treeSet.isEmpty();
        System.out.println("TreeSet是否为空："+isEmpty);
        boolean isContain = treeSet.contains("who");
        System.out.println("TreeSet是否包含who元素："+isContain);

        //元素删除：
        boolean jiaboyanRemove = treeSet.remove("jiaboyan");
        System.out.println("jiaboyan元素是否被删除"+jiaboyanRemove);
        
        //集合中不存在的元素，删除返回false
        boolean whoRemove = treeSet.remove("who");
        System.out.println("who元素是否被删除"+whoRemove);

       //删除并返回第一个元素：如果set集合不存在元素，则返回null
        String pollFirst = treeSet.pollFirst();
        System.out.println("删除的第一个元素："+pollFirst);
        
        //删除并返回最后一个元素：如果set集合不存在元素，则返回null
        String pollLast = treeSet.pollLast();
        System.out.println("删除的最后一个元素："+pollLast);


        treeSet.clear();//清空集合:
    }
}

1.6TreeSet元素排序

代码展示如下：

public class TreeSetTest {
    public static void main(String[] agrs){
        naturalSort();
    }

    //自然排序顺序：升序
    public static void naturalSort(){
        TreeSet<String> treeSetString = new TreeSet<String>();
        treeSetString.add("a");
        treeSetString.add("z");
        treeSetString.add("d");
        treeSetString.add("b");
        System.out.println("字母顺序：" + treeSetString.toString());

        TreeSet<Integer> treeSetInteger = new TreeSet<Integer>();
        treeSetInteger.add(1);
        treeSetInteger.add(24);
        treeSetInteger.add(23);
        treeSetInteger.add(6);
        System.out.println(treeSetInteger.toString());
        System.out.println("数字顺序：" + treeSetString.toString());
    }
}

更多详细内容参考该博客
Set集合知识详解