几种常见语言的基本语法对比：集合

public E next(),java 的迭代器的方法 直接是返回元素，和oc的基本一样。oc也是返回对象，而且方法名都直接指出了 obj=[it nextObject]，依稀记得c++的迭代器是一个类，提供了 ++的 方法。而其他语言是直接next object。隐藏了移动迭代器的动作。

c++:

对比了几个语言，真不想写，也写不来c++，单独之后补上吧。 c++，学之者生，用之者死。

oc:集合，单单使用是非常简单的，反正也不需要 我们去实现hash或树来设计一个集合容器。

1.oc的容器固定了，必须装指针，或扁平数据，  也好。不像c++，还可以装对象本身。

2.for in .这个和其他语言的 for each 一样，其实就是某些实现了迭代或某种链表的数据结构 ，所提供的一个遍历的语法糖。因为不提供索引。如set，是无顺序的，没理由索引，随便插入一个，位置无序变化。所以只提供next功能。一面误解吧。

//
//  arraystudy.m
//  HIWorld
//
//  Created by linson on 2018/9/5.
//  Copyright © 2018年 linson. All rights reserved.
//

#import "arraystudy.h"

@implementation arraystudy

//可以很清楚的看出和c++ 的不同。 oc的集合。里面的元素就就是对象指针。不会去放一个对象， NSMutableArray<NSString> *mybooks=nil; 这样是编译不过的。
//oc 的静态函数，写一个+符号就可以。。。莫名喜感。
//一句话，对比c++ , oc是个好用的语言。

+(void)Showme
{
    //[self fixarray];
    //[self changenableArray];
    [self studySet2];
    
    //[self studySet];
}

+(void)studySet2
{
    NSMutableSet<NSString*> * books=[NSMutableSet new];
    
    //insert
    [books addObject:@"c++"];
    [books addObject:@"c#"];
    [books addObject:@"java"];
    [books addObject:@"banana"];
    
    //delete
    //看到这里就想起c++ 的erase. c++ 的删除，大部分使用删除某个迭代器，那么在 循环中，删除，就要考虑删除的是否是最后一个。为什么不加一个方法呢？
    [books removeObject:@"banana"];
    
    
    for(NSString *mybook in books)
    {
        NSLog(@"%@",mybook);
    }
}


+(void)studySet
{
    NSArray *books1=@[@"c++",@"java",@"c++",@"c#"];
    
    NSSet<NSString*> *books=[[NSSet alloc]initWithArray:books1];//这里为什么不可以简便初始化呢？也好吧。
    
    //traverse
    NSArray<NSString*>  *arraybooks= [books allObjects];
    for(int i=0;i<[arraybooks count];i++)
    {
        NSLog(@"name:%@",arraybooks[i]);
    }

    //enum traverse
    NSEnumerator *it=[books objectEnumerator];
    NSString *obj=nil;
    while ((obj=[it nextObject])!=nil)
    {
        NSLog(@"%@",obj);
    }
    
    //for in.其实就是enum 上面方法的一个语法糖。实现了enum接口色任意集合。那么用一个语法糖来 隐藏 NSEnumerator 实现 travese.
    for(NSString *book in books)
    {
        NSLog(@"traverse book: %@",book);
    }
}


+(void)changenableArray
{
    //add
    NSMutableArray<NSString *> *books=[NSMutableArray<NSString *> new];
    [books addObject:@"c++"];
    [books addObject:@"java"];
    [books addObject:@"oc"];
    [books addObject:@"orange"];
    
    for(int i=0;i<[books count];i++)
    {
        NSLog(@"book name:%@",books[i]);
    }
    //modify
    books[2]=@"objective c";
    
    //delete
    [books removeObjectAtIndex:3];
    
    for(int i=0;i<[books count];i++)
    {
        NSLog(@"2book name:%@",books[i]);
    }
}

+(void)fixarray
{
    NSArray<NSString *> *books=@[@"c++",@"java"];//语法有点怪的。@”表示这个数组类型是属于Objective-C类型的。里面的”@”表示字符串属于Oc 的string. 否则就是c,c++的。而且是方括号，不是大括号。
    
    for(int i=0;i<[books count];i++)
    {
        NSLog(@"name:%@",books[i]);
    }
}

@end

c#

随便写下，最常用的2个。高级语言已经做的非常方便了。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace helloworld
{
    public abstract class arraystudy
    {
        public static void  ShowMe()
        {
            list();
            dictionary();
        }


        public static void list()
        {
            List<string> books = new List<string>();
            books.Add("c++");
            books.Add("c#");
            books.Add("java");

            foreach(string bookname in books)
            {
                Console.WriteLine(bookname);
            }
        }

        public static void dictionary()
        {
            Dictionary<int, string> books2 = new Dictionary<int, string>();
            //insert
            books2.Add(9, "c++");
            books2.Add(6, "java");
            books2.Add(11, "tea");

            books2.Remove(11);

            //get
            Console.WriteLine(books2[6]);

            //reversa
            foreach (KeyValuePair<int, string> pair in books2)
            {
                Console.WriteLine(pair.Value);
            }
        }
    }
}

java

和c#基本意思。基本一样。

//主要掌握主要的集合.和如何遍历他们.基本数组, 可变集合,不重复集合,字典类型    java 是list  set  map.
    public static void Study_Array()
    {
        String[] books={"c#","c++","c","java","oc"};
        for(int i=0;i<books.length;i++)
        {
            System.out.println(books[i]);
        }
        
        //list arraylist .linkedlist
        List<String> booksList=new LinkedList<String>(); //new ArrayList<String>();
        booksList.add("c#");
        booksList.add("c#234");
        booksList.add("c");
        for(int i=0;i<booksList.size();i++)
        {
            System.out.println(booksList.get(i));
        }
        System.out.println("array remove ..............");
        booksList.remove(1);
        for(int i=0;i<booksList.size();i++)
        {
            System.out.println(booksList.get(i));
        }
        
        
        //set treeset hashset.
        Set<String> bookset=new TreeSet<String>();
        bookset.add("c#");
        bookset.add("java");
        bookset.add("c");
        
        
        System.out.println("set ..............");
        //猜测看出,迭代项,第一项是指向第一个元素之前的.而不是c++默认的 beginit;
        Iterator<String> it=bookset.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
        
        //恩,熟视无睹,之前看到可枚举,可碟带类型,也没有太在意.一般都是for循环. 其实可碟带的话,就说明,系统可以基于iterator提供一个for each的语法糖给你.
        //而利用普通的for.还 必须先获得某个key的组合,在怎么转换过来 .其实直接用for each吧.用迭代还不如for each .
        System.out.println("set222 ..............");
        for (String mystr : bookset) 
        {
            System.out.println(mystr);
        }

        //map 
        System.out.println("map ..............");
        java.util.Map<Integer, String> mymap = new HashMap<Integer, String>(); 
    
        mymap.put(1, "c++");
        mymap.put(2, "c");
        mymap.put(3, "java");
        
        //不推荐使用.毕竟查来查去.才得到结果.
        for(Integer mykey: mymap.keySet())
        {
            System.out.println(mykey);
            System.out.println(mymap.get(mykey));
        }
        
        System.out.println("map loop..............");
        //碟带起,效率高.
        for(Entry<Integer, String> it2 :mymap.entrySet())
        {
            System.out.println(it2.getKey()+":"+it2.getValue());
        }
        
    }