《大数据和人工智能交流》头条号向广大初学者新增C 、Java 、Python 、Scala、javascript 等目前流行的计算机、大数据编程语言，希望大家以后关注本头条号更多的内容。
一、Collection集合
1、常见的数据结构简介
数组：查询快；删除和插入速度慢
链表：空间不一定连续，删除和插入速度快；查询慢
2、线程安全的概念初步
（1）、在某一时刻，100个人同时抢洗手间
在某一时刻，100线程在抢共享资源，叫做线程不安全
（2）、在某一时刻，100个人中只能有一个人在用洗手间
在某一时刻，100个线程中只能有一个线程在用共享资源，叫做线程安全
3、集合
List
（1）ArrayList
使用数组设计的；查询快，效率高；新增删除慢；线程不安全
（2）LinkedList
使用链表设计的；查询慢；删除和插入速度快，效率高；线程不安全
例如：
public static void main(String[] args)
{
List<String> list=new LinkedList<String>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
for(String s:list)
{
System.out.println(s);
}
}
（3）Vector
使用数组设计的；查询快；线程安全，效率低
示例：
public static void main(String[] args)
{
List<String> v=new Vector<String>();
v.add("aaa");
v.add("bbb");
v.add("ccc");
for(String s:v)
{
System.out.println(s);
}
}
二、Set集合
Set集合特点：元素无序；元素唯一
1、HashSet：
（1） 底层用的hash表；HashSet是使用数组和链表设计的，兼有数组的查询快和链表的增删快的优点为一身
（2）对象的hash码、equals的概念
一般结论：不同的对象的hashCode不同 ；String特殊因为String重写了hashCode()和equals()重写
例如：
String s1="abc";
String s2=new String("abc");
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
我们可以人为重写，例如：
public class Demo
{
@Override
public int hashCode() {
// TODO Auto-generated method stub
return 100;
}
public static void main(String[] args)
{
System.out.println(new Demo().hashCode()==new Student().hashCode());
}
}
public class Student {
@Override
public int hashCode() {
// TODO Auto-generated method stub
return 100;
}
}
2、HashSet为什么数据元素唯一
（1） hashCode相同：quals相同，说明数据重复，不能添加；quals不相同，说明数据不重复，可以添加
（2） hashCode不相同：直接可以添加
HashSet举例：
public static void main(String[] args)
{
Set<Student> set=new HashSet<Student>();
set.add(new Student("lily001"));
set.add(new Student("lily002"));
for(Student s:set)
{
System.out.println(s.hashCode());
}
}
3、TreeSet
【1】底层设计原理：采用二叉树，红黑树
【2】TreeSet天生就能对数据排序，但是我们自定义的对象你得实现Comparable 和Comparator接口
【3】对象排序实现Comparable 和Comparator
（1）使用Comparable 给对象排序
public class Goods implements Comparable<Goods>{
private String gid;
private String gname;
private float gprice;
public String getGid() {
return gid;
}
public void setGid(String gid) {
this.gid = gid;
}
public String getGname() {
return gname;
}
public void setGname(String gname) {
this.gname = gname;
}
public float getGprice() {
return gprice;
}
public void setGprice(float gprice) {
this.gprice = gprice;
}
public Goods(String gid, String gname, float gprice) {
this.gid = gid;
this.gname = gname;
this.gprice = gprice;
}
public int compareTo(Goods goods) {
float f=this.gprice-goods.gprice;
if(f>0)
{
return 1;
}
if(f<0)
{
return -1;
}
return 0;
}
}
public class Demo
{
public static void main(String[] args)
{
Set<Goods> set=new TreeSet<Goods>();
set.add(new Goods("g001","book001",212));
set.add(new Goods("g002","book002",100));
set.add(new Goods("g003","book003",913));
for(Goods g:set)
{
System.out.println(g.getGprice());
}
}
}
（2）使用Comparator<T>实现排序
第一步：有不可更改的实体类
public class Goods {
private String gid;
private String gname;
private float gprice;
public String getGid() {
return gid;
}
public void setGid(String gid) {
this.gid = gid;
}
public String getGname() {
return gname;
}
public void setGname(String gname) {
this.gname = gname;
}
public float getGprice() {
return gprice;
}
public void setGprice(float gprice) {
this.gprice = gprice;
}
public Goods(String gid, String gname, float gprice) {
this.gid = gid;
this.gname = gname;
this.gprice = gprice;
}
}
第二步：自定义类实现Comparator<T>接口
public class MyGoods implements Comparator<Goods>{
@Override
public int compare(Goods o1, Goods o2) {
// TODO Auto-generated method stub
float f=o1.getGprice()-o2.getGprice();
if(f>0)
{
return 1;
}
if(f<0)
{
return -1;
}
return 0;
}
}
第三步：
public static void main(String[] args)
{
//生成自定义的MyGoods对象
MyGoods myGoods=new MyGoods();
//使用重载的构造方法TreeSet(Comparator<? super E> comparator)
Set<Goods> set = new TreeSet<Goods>(myGoods);
set.add(new Goods("g001","book001",212));
set.add(new Goods("g002","book002",100));
set.add(new Goods("g003","book003",913));
for(Goods g:set)
{
System.out.println(g.getGprice());
}
}
三、迭代器Iterator
1、依赖于集合对象而存在
示例1：
public static void main(String[] args)
{
List<String> list=new ArrayList<String>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
Iterator<String> it = list.iterator();
while(it.hasNext())
{
String s = it.next();
System.out.println(s);
}
}
示例2：
public static void main(String[] args)
{
Set<String> set=new TreeSet<String>();
set.add("aaa");
set.add("bbb");
set.add("ccc");
Iterator<String> it = set.iterator();
while(it.hasNext())
{
String s = it.next();
System.out.println(s);
}
}
2、因为集合对象有多种形态，比如List、Set，接口是实现多态的最佳选择
四、map数据结构
map存储键值对key-value结构的数据
Map---HashMap
----TreeMap
Dictionary类--> HashTable
Map示例-1：
Map<String,String> map=new HashMap<String,String>();
map.put("010", "北京");
map.put("021", "上海");
map.put("0451", "哈尔滨");
//map对象有keySet()返回 Set对象
Set<String> keys = map.keySet();
for(String k:keys)
{
String v = map.get(k);
System.out.println(k+"====="+v);
}
示例-2：TreeMap自然排序
public static void main(String[] args)
{
Map<String,String> map=new TreeMap<String,String>();
map.put("aaa", "111");
map.put("ddd", "333");
map.put("ccc", "666");
map.put("bbb", "888");
//map对象有keySet()返回 Set对象
Set<String> keys = map.keySet();
for(String k:keys)
{
String v = map.get(k);
System.out.println(k+"====="+v);
}
}
示例-3：非自然排序实现
public class Goods {
private String gid;
private String gname;
private float gprice;
public String getGid() {
return gid;
}
public void setGid(String gid) {
this.gid = gid;
}
public String getGname() {
return gname;
}
public void setGname(String gname) {
this.gname = gname;
}
public float getGprice() {
return gprice;
}
public void setGprice(float gprice) {
this.gprice = gprice;
}
public Goods(String gid, String gname, float gprice) {
this.gid = gid;
this.gname = gname;
this.gprice = gprice;
}
}
public class MyGoods implements Comparator<Goods>{
@Override
public int compare(Goods o1, Goods o2) {
// TODO Auto-generated method stub
float f=o1.getGprice()-o2.getGprice();
if(f>0)
{
return 1;
}
if(f<0)
{
return -1;
}
return 0;
}
}
public static void main(String[] args)
{
MyGoods my=new MyGoods();
Map<Goods,String> map=new TreeMap<Goods,String>(my);
map.put(new Goods("g001","book001",300), "111");
map.put(new Goods("g002","book002",100), "333");
map.put(new Goods("g003","book003",200), "666");
//map对象有keySet()返回 Set对象
Set<Goods> keys = map.keySet();
for(Goods k:keys)
{
String v = map.get(k);
System.out.println(k.getGprice()+"====="+v);
}
}
面试题
1、HashMap和Hashtable的区别
HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都完成了Map接口，主要区别在于HashMap允许空（null）键值（key）,由于非线程安全，在只有一个线程访问的情况下，效率要高于Hashtable
HashMap允许将null作为一个entry的key或者value，而Hashtable不允许。
HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因为contains方法容易让人引起误解
Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Map interface的一个实现。
最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap 就必须为之提供外同步。
Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。
就HashMap与HashTable主要从三方面来说。
一.历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现
示例：
public static void main(String[] args)
{
Hashtable<String,String> hs=new Hashtable<String,String>();
hs.put("010", "aaa");
hs.put("020", "bbb");
hs.put("030", "ccc");
Set<String> keys = hs.keySet();
for(String k:keys)
{
System.out.println(k+"====="+hs.get(k));
}
}
二.同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的
三.值：只有HashMap可以让你将空值作为一个表的条目的key或value ；Hashtable的key和value不能为null
下列是错误的
public static void main(String[] args)
{
Hashtable<String,String> hs=new Hashtable<String,String>();
hs.put(null, "aaa");
hs.put(null, "bbb");
hs.put("030", "ccc");
Set<String> keys = hs.keySet();
for(String k:keys)
{
System.out.println(k+"====="+hs.get(k));
}
}
2、Collection 和 Collections的区别。
Collection是集合类的上级接口，继承与他的接口主要有Set 和List.
Collections是针对集合类的一个工具类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。
（1）排序
public static void main(String[] args)
{
List<String> list=new ArrayList<String>();
list.add("ddd");
list.add("aaa");
list.add("bbb");
for(String s:list)
{
System.out.println(s);
}
System.out.println("============");
Collections.sort(list);
for(String s:list)
{
System.out.println(s);
}
}
（2） 反转指定列表中元素的顺序。
public static void main(String[] args)
{
List<String> list=new ArrayList<String>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
for(String s:list)
{
System.out.println(s);
}
System.out.println("============");
Collections.reverse(list);
for(String s:list)
{
System.out.println(s);
}
}
（3）给对象排序
第一步：定义个实体类，并且这个实体类不能被修改
public class Goods {
private String gid;
private String gname;
private float gprice;
public String getGid() {
return gid;
}
public void setGid(String gid) {
this.gid = gid;
}
public String getGname() {
return gname;
}
public void setGname(String gname) {
this.gname = gname;
}
public float getGprice() {
return gprice;
}
public void setGprice(float gprice) {
this.gprice = gprice;
}
public Goods(String gid, String gname, float gprice) {
this.gid = gid;
this.gname = gname;
this.gprice = gprice;
}
}
第二步：实现Comparator接口
public class MyGoods implements Comparator<Goods>{
@Override
public int compare(Goods o1, Goods o2) {
// TODO Auto-generated method stub
float f=o1.getGprice()-o2.getGprice();
if(f>0)
{
return 1;
}
if(f<0)
{
return -1;
}
return 0;
}
}
第三步：测试
public class Demo
{
public static void main(String[] args)
{
MyGoods MyGoods();
List<Goods> goodsList=new ArrayList<Goods>();
Goods g1=new Goods("g001","book001",99);
Goods g2=new Goods("g002","book002",88);
Goods g3=new Goods("g003","book003",666);
goodsList.add(g1);
goodsList.add(g2);
goodsList.add(g3);
System.out.println("排序前===============");
for(Goods g:goodsList)
{
System.out.println(g.getGprice()+" "+g.getGid());
}
Collections.sort(goodsList, myGoods);
System.out.println("排序后=============");
for(Goods g:goodsList)
{
System.out.println(g.getGprice()+" "+g.getGid());
}
}
}
《大数据和人工智能交流》的宗旨
1、将大数据和人工智能的专业数学：概率数理统计、线性代数、决策论、优化论、博弈论等数学模型变得通俗易懂。
2、将大数据和人工智能的专业涉及到的数据结构和算法：分类、聚类 、回归算法、概率等算法变得通俗易懂。
3、最新的高科技动态：数据采集方面的智能传感器技术；医疗大数据智能决策分析；物联网智慧城市等等。
根据初学者需要会有C语言、Java语言、Python语言、Scala函数式等目前主流计算机语言。
根据读者的需要有和人工智能相关的计算机科学与技术、电子技术、芯片技术等基础学科通俗易懂的文章。