大数据学习day16 Set接口、Map、可变参数

今日内容

  • Set接口中hashSet
  • LinkedHashSet
  • Map集合特点
  • Map集合的遍历方式
  • 方法可变参数
  • 斗地主案例排序
  • 总结

第一章 Set接口(接昨天没学完的)

1.1HashSet集合存储数据的结构（哈希表）

哈希表

什么是哈希表呢？

在JDK1.8之前，哈希表底层采用数组+链表实现，即使用数组处理冲突，同一hash值的链表都存储在一个数组里。但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，哈希表存储采用数组+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间。

  • 哈希表的初始化容量，数组长度为16个。

    • 当数组容量不够时，扩容为原数组长度的2倍
  • 加载因子为0.75。
    • 指示当数组的容量被使用到长度的75%时，进行扩容。

如下图

1.2 HashSet存储自定义类型元素

给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保证HashSet集合中的对象唯一.

创建自定义Student类:

public class Student {private String name;private int age;//get/set@Overridepublic boolean equals(Object o) {if (this == o)return true;if (o == null || getClass() != o.getClass())return false;Student student = (Student) o;return age == student.age &&Objects.equals(name, student.name);}@Overridepublic int hashCode() {return Objects.hash(name, age);}
}

创建测试类:

public class HashSetDemo2 {public static void main(String[] args) {//创建集合对象   该集合中存储 Student类型对象HashSet<Student> stuSet = new HashSet<Student>();//存储 Student stu = new Student("于谦", 43);stuSet.add(stu);stuSet.add(new Student("郭德纲", 44));stuSet.add(new Student("于谦", 43));stuSet.add(new Student("郭麒麟", 23));stuSet.add(stu);for (Student stu2 : stuSet) {System.out.println(stu2);}}
}
执行结果：
Student [name=郭德纲, age=44]
Student [name=于谦, age=43]
Student [name=郭麒麟, age=23]

1.3LinkedHashSet

我们知道HashSet保证元素唯一，可是元素存放进去是没有顺序的，那么我们要保证有序，怎么办呢？

在HashSet下面有一个子类java.util.LinkedHashSet，底层数据结构是链表和哈希表的组合,其中链表保证元素有序 哈希表保证元素唯一:即先比较hashCode值 不同 添加到集合 相同 继续比较equals 不同 添加进集合 相同 不添加。

此实现与 HashSet的不同之外在于，后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，即按照将元素插入到 set 中的顺序（插入顺序）进行迭代。

public class Demo01_LinkedHashSet {public static void main(String[] args) {Set<Person> set = new LinkedHashSet<>();set.add(new Person("柳岩",38));set.add(new Person("唐嫣",18));set.add(new Person("柳岩",38));//        System.out.println(set);Iterator<Person> it = set.iterator();while (it.hasNext()){Person p =   it.next();System.out.println(p.getName() + " "+p.getAge());}for(Person p : set){System.out.println(p.getName() + " "+p.getAge());}}
}

第二章 Map集合 映射

2.1 概述

现实生活中，我们常会看到这样的一种集合：IP地址与主机名，身份证号与个人，系统用户名与系统用户对象等，这种一一对应的关系，就叫做映射。Java提供了专门的集合类用来存放这种对象关系的对象，即java.util.Map接口。

我们通过查看Map接口描述，发现Map接口下的集合与Collection接口下的集合，它们存储数据的形式不同，如下图。

  • Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。
  • Map中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成，通过键可以找对所对应的值。
  • Collection中的集合称为单列集合，Map中的集合称为双列集合。
  • 需要注意的是，Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。

2.2 Map接口中的常用方法

  • public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。
  • public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
  • public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
  • public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。
  • public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。
  • public boolean containKey(Object key):判断该集合中是否有此键。
  • public Collection<V> values() 返回Map集合中的所有值到Collection集合。
public class Demo01_Map {public static void main(String[] args) {Map<String,Integer>  map =  new TreeMap<>();
//        map = new HashMap<>();
//        map = new LinkedHashMap<>();map.put("柳岩",38);map.put("唐嫣",18);map.put("金莲",138);map.put("大郎", 8);//如果键相同 值会覆盖 会返回被覆盖的值
//        Integer in = map.put("大郎", 108);
//        System.out.println(in);System.out.println(map);//        //根据键找值
//        Integer integer = map.get("柳岩");
//        System.out.println(integer);
//
//        //判断集合是否包含指定键
//        boolean b = map.containsKey("柳岩");
//        System.out.println(b);//根据键删除一对元素 返回被删除的值Integer removeValue = map.remove("柳岩");System.out.println(removeValue);System.out.println(map);}
}public class Demo02_Map {public static void main(String[] args) {Map<String,Integer> map =  new TreeMap<>();map.put("柳岩",38);map.put("唐嫣",18);map.put("金莲",138);map.put("大郎", 8);//添加元素 键相同 值不覆盖 返回原来的值
//        Integer value = map.putIfAbsent("大郎", 108);
//        System.out.println(value);
//        System.out.println(map);//根据键找值 如果有指定键 返回对应的值 如果没有给定键 则返回给定的默认值
//        Integer value2 = map.getOrDefault("柳岩2", 100);
//        System.out.println(value2);//根据键和值删除 一对元素 键和值都相同 才能删除boolean b = map.remove("柳岩", 38);System.out.println(b);System.out.println(map);//1.8 默认方法
//        map.forEach(new BiConsumer<String, Integer>() {//            @Override
//            public void accept(String key, Integer value) {//                System.out.println(key+" "+value);
//            }
//        });//      map.forEach((k,v)-> System.out.println(k+" "+v));}
}

注意：使用put方法时，若指定的键(key)在集合中没有，则没有这个键对应的值，返回null，并把指定的键值添加到集合中； 若指定的键(key)在集合中存在，则返回值为集合中键对应的值（该值为替换前的值），并把指定键所对应的值，替换成指定的新值。

2.3 Map集合遍历

方式1:键找值方式

通过元素中的键，获取键所对应的值

分析步骤：

1.定义Map集合 添加数据
2.调用keySet方法 获取存储所有键的Set集合
3.遍历Set集合 依次获取到每个元素(Map集合的key)
4.调用Map集合的get方法 根据键找到对应的值

遍历图解：

代码演示

public class Demo03_Map {public static void main(String[] args) {Map<String,Integer> map = new HashMap<>();map.put("柳岩",38);map.put("唐嫣",18);map.put("金莲",138);map.put("大郎", 8);// 2.调用keySet方法 获取存储所有键的Set集合Set<String> set = map.keySet();//迭代器Iterator<String> it = set.iterator();while(it.hasNext()){// 3.遍历Set集合 依次获取到每个元素(Map集合的key)String key = it.next();//4.调用Map集合的get方法 根据键找到对应的值Integer value = map.get(key);System.out.println(key+" = "+value);}//增强forfor(String key : set){System.out.println(key+" = "+map.get(key));}}
}

方式2:键值对方式

即通过集合中每个键值对(Entry)对象，获取键值对(Entry)对象中的键与值。

Entry键值对对象:

我们已经知道，Map中存放的是两种对象，一种称为key(键)，一种称为value(值)，它们在在Map中是一一对应关系，这一对对象又称做Map中的一个Entry(项)。Entry将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历Map集合时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值。

在Map集合中也提供了获取所有Entry对象的方法：

  • public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。

获取了Entry对象 , 表示获取了一对键和值，那么同样Entry中 , 分别提供了获取键和获取值的方法：

  • public K getKey()：获取Entry对象中的键。
  • public V getValue()：获取Entry对象中的值。

操作步骤与图解：

  1. 获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回。方法提示:entrySet()。
  2. 遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象。
  3. 通过键值对(Entry)对象，获取Entry对象中的键与值。 方法提示:getkey() getValue()

遍历图解：

public class Demo04_Map {public static void main(String[] args) {Map<String,Integer> map = new HashMap<>();map.put("柳岩",38);map.put("唐嫣",18);map.put("金莲",138);map.put("大郎", 8);//2.调用entrySet 获取到存储结婚证(键值对映射关系对象)的Set集合Set<Map.Entry<String,Integer>> set =  map.entrySet();//迭代器Iterator<Map.Entry<String,Integer>> it = set.iterator();while(it.hasNext()){//3.遍历Set集合 依次获取到每个结婚证 对象Map.Entry<String,Integer> en  = it.next();// 4.调用结婚证对象的方法 获取到 键 和值String key = en.getKey();Integer value = en.getValue();System.out.println(key + " = "+value);}for(Map.Entry<String,Integer> en: set){System.out.println(en.getKey() + " = "+en.getValue());}}
}

2.4 HashMap集合

Map接口实现类HashMap类特点：

  • 底层哈希表结构。
  • 不允许重复键。
    • 用作键的对象，应该重写hashCode()方法和equals()方法。
  • 此集合可以使用null值和null键。
  • 线程不安全，运行速度快。

2.5 HashMap存储自定义对象

//定义Person类public class Person {private String name;private int age;public Person() {}public Person(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic String toString() {return  name +" "+age;}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Person person = (Person) o;if (age != person.age) return false;return name != null ? name.equals(person.name) : person.name == null;}@Overridepublic int hashCode() {int result = name != null ? name.hashCode() : 0;result = 31 * result + age;return result;}
}

测试类：

public class Demo01_HashMap {public static void main(String[] args) {Map<Person,String> map = new HashMap<>();//允许null键和null值
//        map.put(null,null);
//        map.put(null,"aaa");map.put(new Person("柳岩",38),"bj");map.put(new Person("唐嫣",18),"sh");map.put(new Person("小苍",50),"rb");map.put(new Person("小苍",50),"sj");
//        System.out.println(map);//keySetSet<Person> set = map.keySet();for(Person key : set){System.out.println(key.getName()+" "+key.getAge()+" = "+map.get(key));}//entrySetSet<Map.Entry<Person,String>> set2 = map.entrySet();for(Map.Entry<Person,String> en: set2){Person key = en.getKey();String value = en.getValue();System.out.println(key.getName()+" "+key.getAge()+" = "+map.get(key));}}
}
运行结果
柳岩 38 = bj
唐嫣 18 = sh
小苍 50 = sj
柳岩 38 = bj
唐嫣 18 = sh
小苍 50 = sj
  • 当给HashMap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须复写对象的hashCode和equals方法(如果忘记，请回顾HashSet存放自定义对象)。
  • 如果要保证map中存放的key和取出的顺序一致，可以使用java.util.LinkedHashMap集合来存放。

2.6 LinkedHashMap介绍

我们知道HashMap保证成对元素唯一，并且查询速度很快，可是成对元素存放进去是没有顺序的，那么我们要保证有序，还要速度快怎么办呢？

在HashMap下面有一个子类LinkedHashMap，底层是哈希表双向链表，保证迭代的顺序。

public static void main(String[] args) {LinkedHashMap<String, String> map = new LinkedHashMap<String, String>();map.put("邓超", "孙俪");map.put("李晨", "范冰冰");map.put("刘德华", "朱丽倩");Set<Entry<String, String>> entrySet = map.entrySet();for (Entry<String, String> entry : entrySet) {System.out.println(entry.getKey() + "  " + entry.getValue());}
}

2.7 Properties集合

Map接口实现类Hashtable的子类Properties类。Properties也是Map接口实现类，是存储键值对的双列集合，由于此类能和IO流结合使用，数据可以持久化，使用量很大。（IO部分后面课程详解）

Properties集合特点：

  • 继承Hashtable，底层数据结构是哈希表。
  • 线程安全，运行速度慢。
  • 不允许null值，null键。
  • 此集合存储键值对数据类型固定为String。
  • 可以和IO流结合使用，从流中加载数据。

Properties集合特有方法：

  • Object setPropery(String key,String value)，向集合中存储键值对。
  • String getProperty(String key)，获取集合中键对应的值，无此键返回null。
  • Set<String> stringPropertyNames()，集合中的所有键存储到Set集合。
  • void load(输入流对象) ，IO部分讲解。
public class Demo01_Properties {public static void main(String[] args) {Properties p = new Properties();p.setProperty("name","liuyan");p.setProperty("age","38");p.setProperty("email","123@qq.com");
//        System.out.println(p);Set<String> set = p.stringPropertyNames();for(String key : set){String value = p.getProperty(key);System.out.println(key + " = "+value);}}
}
运行结果
age = 38
name = liuyan
email = 123@qq.com

2.8 TreeMap集合yun

​ TreeMap集合基于红黑树实现,该映射根据其键的[自然顺序]进行排序，或者根据创建映射时提供Comparator
进行排序，具体取决于使用的构造方法。

构造方法 描述
TreeMap() 使用键的自然顺序构造一个新的、空的树映射,必须实现自然排序接口。
TreeMap(Comparator<? super K> comparator) 构造一个新的、空的树映射，该映射根据给定比较器进行排序。
TreeMap(Map<? extends K,? extends V> m) 构造一个与给定映射具有相同映射关系的新的树映射，该映射根据其键的自然顺序 进行排序。 
//定义Person类
public class Person implements Comparable<Person>{private String name;private int age;public Person() {}public Person(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +'}';}@Overridepublic int compareTo(Person o) {if(this.age == o.age){return  this.name.compareTo(o.name);}return this.age - o.age;}
}

public class Demo01_TreeMap {public static void main(String[] args) {Map<Person,String> map = new TreeMap<>(new Comparator<Person>() {@Overridepublic int compare(Person o1, Person o2) {if(o2.getAge() == o1.getAge()){return  o2.getName().compareTo(o1.getName());}return o2.getAge() - o1.getAge();}});//不允许null键 允许null值// map.put(10,null);map.put(new Person("柳岩",38),"bj");map.put(new Person("唐嫣",18),"sh");map.put(new Person("小苍",50),"rb");map.put(new Person("小苍",50),"sj");System.out.println(map);System.out.println("----------------------------------------------");Map<Integer,String> hashMap = new LinkedHashMap<>();hashMap.put(1,"aaa");hashMap.put(3,"aaa");hashMap.put(2,"aaa");hashMap.put(4,"aaa");//System.out.println(hashMap);Map<Integer,String> treeMap = new TreeMap<>(hashMap);System.out.println(treeMap);}
}
运行结果
{Person{name='小苍', age=50}=sj, Person{name='柳岩', age=38}=bj, Person{name='唐嫣', age=18}=sh}
----------------------------------------------
{1=aaa, 2=aaa, 3=aaa, 4=aaa}
  • public Map.Entry<K,V> ceilingEntry(K key): 返回一个键-值映射关系，它与大于等于给定键的最小键关联；如果不存在这样的键，则返回 null。
  • public K ceilingKey(K key): 返回大于等于给定键的最小键；如果不存在这样的键，则返回 null。
  • public Map.Entry<K,V> firstEntry() 返回一个与此映射中的最小键关联的键-值映射关系；如果映射为空，则返回 null。
  • public Map.Entry<K,V> lastEntry(): 返回与此映射中的最大键关联的键-值映射关系；如果映射为空，则返回 null。
  • public K firstKey(): 返回此映射中当前第一个（最低）键。
  • public K lastKey():返回映射中当前最后一个（最高）键。
public class Demo02_TreeMap {public static void main(String[] args) {TreeMap<Integer,String> map = new TreeMap<>();map.put(10,"aa");map.put(30,"aa");map.put(20,"aa");map.put(40,"aa");//获取最小键Integer firstKey = map.firstKey();System.out.println(firstKey);//获取最小键的键值对Map.Entry<Integer, String> firstEntry = map.firstEntry();System.out.println(firstEntry);//获取最大键Integer lastKey = map.lastKey();System.out.println(lastKey);//获取最大键的键值对Map.Entry<Integer, String> lastEntry = map.lastEntry();System.out.println(lastEntry);System.out.println("---------------------------");//获取 >=指定键的 最小键Integer ceilingKey = map.ceilingKey(15);System.out.println(ceilingKey);Map.Entry<Integer, String> ceilingEntry = map.ceilingEntry(11);System.out.println(ceilingEntry);//获取 <=指定键的 最小键Integer floorKey = map.floorKey(15);System.out.println(floorKey);Map.Entry<Integer, String> floorEntry = map.floorEntry(25);System.out.println(floorEntry);}
}

2.8 Map集合练习

需求：

计算一个字符串中每个字符出现次数。

分析：

  1. 获取一个字符串对象
  2. 创建一个Map集合，键代表字符，值代表次数。
  3. 遍历字符串得到每个字符。
  4. 判断Map中是否有该键。
  5. 如果没有，第一次出现，存储次数为1；如果有，则说明已经出现过，获取到对应的值进行++，再次存储。
  6. 打印最终结果

方法介绍

public boolean containKey(Object key):判断该集合中是否有此键。

public class Test_Map {public static void main(String[] args) {Scanner sc = new Scanner(System.in);System.out.println("请输入一个字符串:");String line = sc.nextLine();Map<Character,Integer> map = new TreeMap<>();char[] chs = line.toCharArray();for (char ch : chs) {//判断是否有当前字符 作为键if(map.containsKey(ch)){//有 说明不是第一次添加//需要先获取到值Integer count = map.get(ch);//将值+1 在添加到map集合中map.put(ch,count+1);}else{//没有 说明第一次添加map.put(ch,1);}}System.out.println(map);}
}
运行结果
asdfsadasdasd
{a=4, d=4, f=1, s=4}

第三章 可变参数

3.1 可变参数

在JDK1.5之后，如果我们定义一个方法需要接受多个参数，并且多个参数类型一致，我们可以对其简化.

格式：

修饰符 返回值类型 方法名(参数类型... 形参名){  }

注意事项
1.一个方法只能有一个可变参数
2.如果方法有多个参数 可变参数放到最后
3.最牛的可变参数 Object...obj 任意类型 任意个数

代码演示：

public class Demo01_VarArgs {public static void main(String[] args) {int sum = sum(10, 20);System.out.println(sum);int sum2 = sum(10, 20, 30);System.out.println(sum2);int[] arr = {10,20,30,40};int sum3 = sum(arr);System.out.println(sum3);System.out.println("-----------------------------");ArrayList<String> list = new ArrayList<>();list.add("aa");list.add("bb");list.add("cc");System.out.println(list);/*Collections 集合工具类public static <T> boolean addAll(Collection<T> c, T... elements):*/Collections.addAll(list,"abc","bcd","aaa","bbb");System.out.println(list);}public static int sum (int...a ){int sum = 0;for (int i : a) {sum += i;}return  sum;}
}
运行结果
30
60
100
-----------------------------
[aa, bb, cc]
[aa, bb, cc, abc, bcd, aaa, bbb]Process finished with exit code 0

注意：

  • 可变参数的本质是数组。

    • 不传递参数，数组的长度是0.
    • 传递几个参数，数组的长度就是几。
  • 一个方法中只能有一个可变参数。
  • 如果方法中有多个参数，可变参数只能写在最后一位。

3.2 可变参数应用

在Collections中也提供了添加一些元素方法：

public static <T> boolean addAll(Collection<T> c, T... elements) :往集合中添加一些元素。

public static void main(String[] args) {ArrayList<Integer> list = new ArrayList<Integer>();//原来写法//list.add(12);//list.add(14);//list.add(15);//list.add(1000);//采用工具类 完成 往集合中添加元素  Collections.addAll(list, 5, 222, 1，2);System.out.println(list);
}

第四章 斗地主案例排序

4.1 案例介绍

按照斗地主的规则，完成洗牌发牌的动作。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-n1wEbKMI-1681214015627)(img/斗地主.png)]

具体规则：

  1. 组装54张扑克牌将。
  2. 54张牌顺序打乱。
  3. 三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。
  4. 查看三人各自手中的牌（按照牌的大小排序）、底牌。

规则：手中扑克牌从大到小的摆放顺序：大王,小王,2,A,K,Q,J,10,9,8,7,6,5,4,3。

4.2 案例需求分析

  1. 准备牌：

完成数字与纸牌的映射关系：

使用双列Map(HashMap)集合，完成一个数字与字符串纸牌的对应关系(相当于一个字典)。

  1. 洗牌：

通过数字完成洗牌发牌

  1. 发牌：

将每个人以及底牌设计为ArrayList,将最后3张牌直接存放于底牌，剩余牌通过对3取模依次发牌。

存放的过程中要求数字大小与斗地主规则的大小对应。

将代表不同纸牌的数字分配给不同的玩家与底牌。

  1. 看牌：

通过Map集合找到对应字符展示。

通过查询纸牌与数字的对应关系，由数字转成纸牌字符串再进行展示。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wiNMlMzI-1681214015627)(img/斗地主分析.png)]

4.3 代码实现

public class PooKer {public static void main(String[] args) {//定义一个Map集合用来存储 牌索引  扑克牌Map<Integer,String>map = new HashMap<>();//定义一个list集合 存储牌索引List<Integer> suoYin = new ArrayList<>();//定义花色数组String[] colors = {"♥","♠","♣","♦"};//定义牌的数组String[] nums = "2-3-4-5-6-7-8-9-10-J-Q-K-A".split("-");int index= 2;//定义牌的索引for (String num : nums) {for (String color : colors) {String thispooKer = color + num;map.put(index,thispooKer);index ++ ;}}//单独添加大小王map.put(0,"大												


											

大数据学习day16-Set接口、Map、可变参数相关推荐
	

    
								
  1. 大数据学习之路 JUC篇
		
    大数据学习之路 JUC篇(1) 前提说明 本人是一名学生,茫茫it行业的一名卑微的小白,这是我第一次写博客.其原因是学着学着知识发现回顾的时候差不多全忘记了!!为了总结.复习自己以往学到过的有关大数据 ...
    
		
    2. 
						
  2. 23.大数据学习之旅——scala进阶
		
    函数式编程的概念 编程范式 函数式编程是一种编程范式,我们常见的编程范式有: 1)命令式编程(Imperative programming),常见的面向对象编程是也是一种命令式编 程.比如java,c ...
    
		
    3. 
						
  3. 大数据学习之路（七）——学习小结
		
    个人目前学习的总结,如有问题,发现的时候会修正,用于个人回顾,有错误的地方欢迎留言指出 通过前几篇的学习 hadoop单节点伪分布式 hadoop完全分布式 hadoop完全分布式高可用(HA) zo ...
    
		
    4. 
						
  4. 【大数据】最新大数据学习路线（完整详细版，含整套教程）
		
    大数据学习路线 java(Java se,javaweb) Linux(shell,高并发架构,lucene,solr) Hadoop(Hadoop,HDFS,Mapreduce,yarn,hive, ...
    
		
    5. 
						
  5. 大数据学习笔记：Hadoop生态系统
		
    文章目录 一.Hadoop是什么 二.Hadoop生态系统图 三.Hadoop生态圈常用组件 (一)Hadoop (二)HDFS (三)MapReduce (四)Hive (五)Hbase (六)Zo ...
    
		
    6. 
						
  6. 零基础大数据学习框架
		
    大数据开发最核心的课程就是Hadoop框架,几乎可以说Hadoop就是大数据开发.这个框架就类似于Java应用开发的SSH/SSM框架,都是Apache基金会或者其他Java开源社区团体的能人牛人开发 ...
    
		
    7. 
						
  7. 大数据学习路线图 让你精准掌握大数据技术学习
		
    大数据指不用随机分析法这样捷径,而采用所有数据进行分析处理的方法.互联网时代每个企业每天都要产生庞大的数据,对数据进行储存,对有效的数据进行挖掘分析并应用需要依赖于大数据开发,大数据开发课程采用真实商 ...
    
		
    8. 
						
  8. 零基础转行大数据怎么学习？大数据学习路线
		
    大数据要怎么学,本文来说说到底要怎么学习它,以及怎么避免大数据学习的误区,以供参考.数据科学特点与大数据学习误区 (1)大数据学习要业务驱动,不要技术驱动:数据科学的核心能力是解决问题. 大数据的核心 ...
    
		
    9. 
						
  9. 史上最全大数据学习资源整理
		
    史上最全大数据学习资源整理 ----------------------------------------------------------------------------------- 转载 ...
    
		
    10. 
		


					

最新文章
	

    
						
  1. 自学python需要多长时间-Python学习步骤如何安排？多长时间可以学会精通呢？
		
    2. 
						
  2. 区分JAVA中的对象和引用
		
    3. 
						
  3. ArcGIS中加载模块时dojo/domReady!和dojo/ready的区别
		
    4. 
						
  4. 带有PostgreSQL的Docker Compose for Spring Boot应用程序
		
    5. 
						
  5. string contains不区分大小写_String基础复习
		
    6. 
						
  6. pytorch 语义分割loss_关于pytorch语义分割二分类问题的两种做法
		
    7. 
						
  7. CHSBO2018游记
		
    8. 
						
  8. Redis 学习（二）
		
    9. 
						
  9. 2021年值得推荐的几个可视化软件
		
    10. 
						
  10. C课设/宾馆客房管理系统/内附源码
		
    11. 
						
  11. Android 反编译修改包名、重新签名、更换app名称
		
    12. 
						
  12. 河南省第二届“金盾信安杯”网络安全大赛 WriteUp Crypto+Misc
		
    13. 
						
  13. android der 编码,关于android：使用现有DER / PEM密钥的Javascript中的RSA加密
		
    14. 
						
  14. layui table 改变列表字体颜色
		
    15. 
						
  15. PyInstaller 打包单文件 exe 注意事项
		
    16. 
						
  16. MyBatis Generator 代码自动生成器，从此解放你的双手
		
    17. 
						
  17. springboot集成easyExcel实现文件导入导出
		
    18. 
						
  18. Linux中传统的IPC机制
		
    19. 
						
  19. Markdown的简单使用方法
		
    20. 
						
  20. iwebsec靶场 中间件漏洞通关笔记2-Tomcat中间件漏洞
		
    21. 
		

	


热门文章
	

    
									
  1. Three.js - RectAreaLight 光源
			
    2. 
						
  2. Linux sudo：无法解析主机 解决方案
			
    3. 
						
  3. python历史性分布计算代码_量化交易中，如何使用Python计算「筹码分布」指标【附代码】 [量化小讲堂-64]...
			
    4. 
						
  4. C# 项目拉完代码引用全是黄色感叹号的处理（附：C#项目提交Git的ignore配置）
			
    5. 
						
  5. 读hzk32_最全HZK12,HZK16,HZK24,HZK32,HZK40,HZK48,ASC12, ASC16,ASC24, ASC32, ASC48字库+读取代码...
			
    6. 
						
  6. BestCoder #92 C (dp)（要学会表示状态啊）
			
    7. 
						
  7. Linux图形界面、文本界面切换方法
			
    8. 
						
  8. 使用火炬之光UI .
			
    9. 
						
  9. Could not receive a message from the daemon
			
    10. 
						
  10. sqlserver之复制表到另一个数据库
			
    11.