List不难使用与办法,iOS学习1陆之OC集合遍历和数组排序

插入排序,是循环遍历3个冬辰数组(例如有13个成分),把遍历出来的数值(第i个成分)插入到已经排过各样的数组(这些不变数组有10-i个要素)中。

一、集合遍历

1、for 循环

java-Collection,List不难使用与格局/(集合使用-中),

1.壹集结只存放引用类型的因素并且集合存放的时成分的引用(地址)
1.二新循环遍历集合
Collection c = new ArrayList();
c.add(“one”);
c.add(“two”);
c.add(“three”);
c.add(“four”);
/*
* 新循环不是新的语法,jvm并不认同新循环。
*
新循环是编写翻译器认同的,当编写翻译器发今后使用新循环遍历集合时,会将代码改变为使用迭代器遍历,所以利用新循环遍历集合的进度中是不能够透过聚合的艺术增删成分的。
*
*/
for (Object object : c) {
String str = (String)object;
System.out.println(str);
}
壹.3见面的操作
boolean addAll(collection c) 将给定的集聚中的成分存入到近来聚集中
当前集合成分发生了变更则赶回true
boolean containsAll(Collection c)
判断当前集结是还是不是含有给定集合中的有着因素
List不难使用与办法,iOS学习1陆之OC集合遍历和数组排序。boolean removeAll(Collection c) 删除当前集结中与给定集合的相同成分
壹.8遍历集合–集合提供联合的遍历成分的点子:迭代器情势
集结提供了用来获取遍历当前集合成分的章程:
java.util.Iterator
Iteartor
iterator()迭代器的接口,规定了遍历集合的方法,遵从的情势为:问,取,删的步骤,在那之中删除成分不是必须操作。差别的会见达成类都提供了2个足以遍历自个儿的迭代器达成类。大家无需记住它们的名字,当他们的Iterator看待即可。
boolean hasNext()判断集合是不是还有成分得以遍历
E next() 取出集合下四个足以遍历的要素
在应用迭代器遍历集合成分的进度中,不能够透过汇集的秘籍增加和删除成分不然会引发迭代器遍历集合的分外,但是迭代器的remove能去除通过next方法取出的成分
一.伍新循环–新循环又称为:增强for循环,for
each,新循环的功用是用来遍历集合或数组—–新循环是JDK1.5随后推出的1个新特色
使用新循环遍历集合:新循环并非新的语法,JVM并不承认新循环。新循环是编写翻译器承认的,当编写翻译器发今后接纳新循环遍历集合时,会将代码改变为运用迭代器遍历。所以使用新循环遍历集合的长河中是不能够经过集合的法子增加和删除成分的。如若在新循环中删除成分会抛出1二分。
1.陆泛型–一.5后头推出的多个表征,泛型是编写翻译器认可泛型的其实类型是Object,在动用的时候编写翻译器会开始展览自笔者批评或自发性造型。当对泛型变量赋值时,编写翻译器检查是或不是合乎项目要求取得泛型值时,编写翻译器会补充自动造型的代码。不点名泛型则默许认为object。泛型用来规定集合中的成分类型
1.7List_get_set–java.util.List
List是Collection的子类型接口。是可重复集,并且稳步,提供了一套能够依据下标操作成分的格局。
常用完成类:
亚洲必赢官网,java.util.ArrayList:数组达成,查询作用高
java.util.LinkedList:链表完结,增加和删除成分功能高特别是前后增加和删除成分。
E get(int index) 将钦命下标所对应的因素重回
E set(int index,E e)
将给定成分替换集合中钦点地点的要素并将被替换来分再次回到。
1.8List_add_remove:List提供了一对重载的add,remove方法也足以因而下标操作成分删除方法会再次来到一个剔除的因素。
1.玖拿走List子集:List<E> subList(int startindex,int endindex)
截取集合中钦赐地方的成分,并回到截取的因素;操作获取的子集的时候就10分操作原有集合
一.10集结账和转账换为数组 —Collection中提供了将近年来聚集转换为2个数组的措施
E[] array= c.toArray(new
E[c.size()]);将聚集转换为数组,传3个泛型数组并设置长度,如果设置长度不够也会重回多个恰巧和要素相等的数组,假若参数长度超过原有数组,则赶回输入长度的数组,未有成分的任务为null。
一.1一数组更换为汇聚—List<String> list =
Arrays.asList(array);将数组转化为集聚,操作再次来到后的集合等于操作原来的数组,并且无法增删成分,假若想增新币素须要新建一个数组将重回数组的值传入并操作。
List<String> list一 = new
ArrayList<String>(list);那些措施能够在开立异数组的同时将原有数组的要素添加进去。

 

笔者是初学者,如有更新倒霉的,欢迎那位大神提议,多谢我们!

更加多优质未来更新,转发注解!

1.一汇合只存放引用类型的元素并且集合存放的时成分的引用(地址)
1.2新循环遍历集合…

用一个 数组 举个例子:

 1> 遍历

  集合(Collection):OC中提供的容器类:数组,字典,集合。

  遍历:对聚集兰月素依次取出的过称叫做遍历。

  两种办法:壹 for循环遍历; 2 NSEnumerator遍历; 三 for…in遍历

let arr = [1,2,3];
for (let i=0; i<arr.length; i++){
 console.log(i,arr[i])
}
// 0 1
// 1 2
// 2 3

早先数组:一, 8九, 四, 3四, 5陆, 40, 5九,
60, 3九, 一, 40, 90, 4八 

 二> for循环遍历

for 循环是 Js 中最常用的3个循环往复工具,日常用来数组的循环遍历。

先是次巡回(i=0):一, 8玖, 4, 34, 5陆, 40, 5九, 60, 3玖, 一, 40, 90,
4八 

  壹 数组遍历

   原理:通过for循环的循环变量用作数组成分下标来博取分歧下标的要素。

   循环次数正是数组成分的个数。

1 // 数组
2 for (int i = 0; i < arr.count; i++) {
3     NSLog(@"%@", arr[i]);
4 }

2、for in 循环

第三遍巡回(i=一):  1, 8九, 肆, 3四, 5陆, 40, 5九, 60, 3九, 一, 40, 90,
4八 

  2 字典遍历

   原理:先拿走字典中存有的key,存款和储蓄到数组中,遍历数组依次取出每1个key,然后根据key从字典中取出对应的value

   循环次数正是字典成分的个数。

1         // 字典
2         // 获取字典中所有的key值
3         NSArray *allKey = [dict allKeys];
4         // 遍历key值数组,访问对应的object值
5         for (int i = 0; i < allKey.count; i++) {
6             NSString *key = allKey[i];
7             NSLog(@"%@", [dict objectForKey:key]);
8         }
let obj = {name:'zhou',age:'**'}
for(let i in obj){
 console.log(i,obj[i])
}
// name zhou
// age **

其二遍巡回(i=2):  1, 四, 89,
3四, 56, 40, 5九, 60, 3九, 壹, 40, 90, 48 

  叁 集合遍历

   原理:用集合的allObjects属性先取到集结的兼具因素存款和储蓄到数组中,再通过for循环的循环变量用作下标来取到各类成分。

1         // 集合
2         // 取出集合中的所有元素放到数组中
3         NSArray *setArray = [set allObjects];
4         for (int i = 0; i < setArray.count; i++) {
5             NSLog(@"%@", setArray[i]);
6         }

for in 循环主要用于遍历普通对象,i 代表对象的 key 值,obj[i]
代表对应的
value,当用它来遍历数组时候,多数气象下也能达到规定的标准平等的效应,可是你不用那样做,那是有风险的,因为
i
输出为字符串形式,而不是数组必要的数字下标,这意味在好几情状下,会发生字符串运算,导致数据失实,比如:’52’+一= ‘5二1’ 而不是咱们要求的 5三。

第伍次巡回(i=3):1, 四, 3四,
8九, 5陆, 40, 5九, 60, 3九, 一, 40, 90,
48 

 3> NSEnumerator

其余 for in 循环的时候,不仅遍历本人的质量,还会找到 prototype
上去,所以最佳在循环体内加3个断定,就用
obj[i].hasOwnProperty(i),那样就幸免遍历出太多不须求的品质。

… …

  ① 概述 

   枚举器,遍历集合中的成分。

   依附于集合类(NSArray,NSSet,NSDictionary),未有用来成立实例的接口。

   NSEnumerator的 nextObject
方法能够遍历种种集合成分,停止重返 nil ,通过与 while
结合使用可遍历集合中保有因素。

   对可变集合(数组,字典,集合)进行枚举操作时,不可能通过丰盛或删除对象那类情势来改变集合容器的要素个数。

3、while 循环

第13次循环(i=12)(结束):1, 1,
4, 34, 39,
40, 40, 48,
56, 59, 60,
89, 90

  二 数组遍历

   正序(objectEnumerator)

1         // 数组(正序)
2         // 创建正序的枚举器对象
3         NSEnumerator *arrayEnum1 = [arr objectEnumerator];
4         id value1 = nil;
5         // 判断value部位空打印数据
6         while ((value1 = [arrayEnum1 nextObject])) {
7             NSLog(@"%@", value1);
8         }    

   倒序(reverseObjectEnumerator)

1         // 数组(倒序)
2         // 创建倒序的枚举器对象
3         NSEnumerator *arrayEnum2 = [arr reverseObjectEnumerator];
4         id value2 = nil;
5         while ((value2 = [arrayEnum2 nextObject])) {
6             NSLog(@"%@", value2);
7         }

  注:枚举器的nextObject方法只可以取出八个指标,所以要求和while循环结合把装有因素依次取出。

  3 字典遍历

1         // 字典
2         // 遍历到的是字典中的value值
3         NSEnumerator *dictEnum = [dict objectEnumerator];
4         id value3 = nil;
5         while ((value3 = [dictEnum nextObject])) {
6             NSLog(@"%@", value3);
7         }

  注:字典中存放的多少是严节的,未有反向枚举的概念。

  四 集合遍历

1         // 集合
2         NSEnumerator *setEnum = [set objectEnumerator];
3         id value4 = nil;
4         while ((value4 = [setEnum nextObject])) {
5             NSLog(@"%@", value4);
6         }

  注:集合中存放的数码是冬辰的,未有反向枚举的定义。

平等的遍历 cars 数组,先用 for 循环方法

int[] sort = new int[13] { 1, 4, 89, 34, 56, 40, 59, 60, 39, 1, 40, 90, 48 };  // 输入一个数组
for (int i = 0; i < sort.Length; i++)
    {
         int temp = sort[i];   // 临时存储第i个数的值
         int j = i;

         for (; j > 0 && temp < sort[j - 1]; j--)  // 遍历有j 个数的有序数组(j从0开始),当 temp 临时值小于sort[j-1](初始是,有j个数,j-1 为最后一个数)时,把当前第(j-1)位上的数向后移一位(j)
              {
                  sort[j] = sort[j - 1];

              }
                sort[j] = temp;  // 退出循环后,把temp 放到 第j 个位置上(j 是经过循环处理后得到的)

    }
for (int i = 0; i < sort.Length; i++) // 输出
    {
         Console.Write(sort[i] + " ");
    }

 4> for…in 遍历

let cars=["BMW","Volvo","Saab","Ford"];
let i=0;
for (;cars[i];)
{
console.log(cars[i])
i++;
};
// BMW
// Volvo
// Saab
// Ford

 

  ① 概述

   for…in:快速枚举,是在NSEnumerator的根基上包裹的尤其有利于的相当的慢的遍历集合成分的方法。

   格式:for (集合中指标的体系 * 成分名 in 被遍历的集结) {

      语句;

       }

   对可变集合(数组,字典,集合)举行高效枚举操作时,无法因而添加或删除对象这类情势来改变集合容器的因素个数。

  二 数组遍历

1         // 数组
2         for (id value in arr) {
3             NSLog(@"%@", value);
4         }

  3 字典遍历

1         // 字典 遍历的是字典的key
2         for (id value in dict) {
3             NSLog(@"%@", dict[value]);
4         }

  4 集合遍历

1         // 集合
2         for (id value in set) {
3             NSLog(@"%@", value);
4         }

接下来是 while 循环方法

二、数组排序

 数组是严守原地容器,因而集合中唯有数组才能排序。

cars=["BMW","Volvo","Saab","Ford"];
var i=0;
while (cars[i])
{
console.log(cars[i] + "<br>")
i++;
};

 1> NSSortDescriptor(排序描述符)概述

  该类能够方便的达成对数组中的对象开始展览升序或许降序的排序。

  它能够把成分的有些属性作为key实行升序或降序的排序,每一种NSSortDescriptor对象就是二个排序条件。

咱们发现,它们能够达成平等的机能,事实上它们底层的处理是壹律的,不过 for
循环能够把定义、条件判断、自增自减操作放到三个原则里进行,代码看起来方便一些,仅此而已。

 二> NSSortDescriptor创造方法

  起头化方法

  - (instancetype)initWithKey:(NSString
*)key ascending:(BOOL)ascending;

  key:依照数组中指标的哪位属性实行排序,假设数组中存放的是力所能及一贯排序的靶子(比如:字符串),直接使
@”self” 或许 nil 即可;假如存放的是自定义类的指标,使用想要实行排序的属性名即可(比如:想规行矩步Person类的name举行排序,
使用 @”name” 作为参数)。
       ascending:排序的注解,是升序照旧降序。
YES – 升序, NO –
降序。

NSSortDescriptor创建

1 NSSortDescriptor *sortDes1 = [[NSSortDescriptor alloc] initWithKey:@"self" ascending:YES]; // 升序
2 NSSortDescriptor *sortDes2 = [[NSSortDescriptor alloc] initWithKey:@"name" ascending:NO]; // 降序

4、do while 循环

  一 不可变数组

排序

1 // 基本数据类型不可变数组
2 array = [array sortedArrayUsingDescriptors:@[sortDes1]];
3 NSLog(@"%@", array);
4 // 自定义对象不可变数组
5 // 按照名字排序
6 personArray = [personArray sortedArrayUsingDescriptors:@[sortDes2]];
7 NSLog(@"%@", personArray);

 2 可变数组

排序

1 // 基本类型可变数组
2 [mArray sortUsingDescriptors:@[sortDes1]];
3 NSLog(@"%@", mArray);
4 // 自定义对象可变数组
5 // 按照名字排序
6 [personMArray sortUsingDescriptors:@[sortDes2]];
7 NSLog(@"%@", personMArray);
let i = 3;
do{
 console.log(i)
 i--;
}
while(i>0)
// 3
// 2
// 1

 三> 使用数组中 三个要素相比的办法名 实行排序

do while 循环是 while
循环的2个变体,它首先实施一回操作,然后才进行标准判断,是 true
的话再继续执行操作,是 false 的话循环结束。

  壹 不可变数组排序:(排序结果生成新数组, 原数组无更改)

   -
(NSArray
*)sortedArrayUsingSelector:(SEL)comparator;

   注:SEL类型的参数comparator:必要传入2个回到结果是NSComparisonResult的法门名。

1 // 不可变数组(基本数据类型)
2 array = [array sortedArrayUsingSelector:@selector(compare:)];
3 NSLog(@"%@", array);
4 // 不可变的数组(自定义类型的对象)
5 // 按照名字排序
6 personArray = [personArray sortedArrayUsingSelector:@selector(compareByName:)]; // compareByName为Person类中自定义的方法
7 NSLog(@"%@", personArray);

5、Array forEach 循环

  二 可变数组排序:(直接对原数组操作,无新数组变化)

   - (void)sortUsingSelector:(SEL)comparator;

   注:SEL类型的参数comparator:供给传入八个回去结果是NSComparisionResult的函数

1 // 可变数组(基本数据类型)
2 [mArray sortUsingSelector:@selector(compare:)];
3 NSLog(@"%@", mArray);
4 // 可变的数组(自定义类型的对象)
5 // 按照名字排序
6 [personMArray sortUsingSelector:@selector(compareByName:)];
7 NSLog(@"%@", personMArray);

  Person类中compareByName方法:

1          // 比较方法的声明
2          - (NSComparisonResult)compareByName:(Person *)anotherPerson;
3          // 比较方法的实现
4          - (NSComparisonResult)compareByName:(Person *)anotherPerson {
5          return [self.name compare:anotherPerson.name];
6          }

 

let arr = [1,2,3];
arr.forEach(function(i,index){
 console.log(i,index)
})
// 1 0
// 2 1
// 3 2

forEach循环,循环数组中每三个因素并行使操作, 未有重回值,
能够毫无知道数总经理度,他有多个参数,唯有首先个是必备的,代表当前下标下的
value。

除此以外请留心,forEach 循环在拥有因素调用完结以前是不能终止的,它并未有 break
语句,假若你必供给停下,能够品尝 try catch
语句,正是在要强制退出的时候,抛出三个 error 给 catch 捕捉到,然后在
catch 里面
return,那样就能暂停循环了,假使你平日用那么些主意,最棒自定义八个这么的
forEach 函数在您的Curry。

6、Array map()方法

let arr = [1,2,3];
let tt = arr.map(function(i){
 console.log(i)
 return i*2;
})
// [2,4,6]

map()
方法重返1个新数组,数组中的成分为原始数组成分调用函数处理后的值。
瞩目:map 和 forEach 方法皆以只好用来遍历数组,无法用来遍历普通对象。

7、Array filter() 方法

let arr = [1,2,3];
let tt = arr.filter(function(i){
 return i>1;
})
// [2,3]

filter 方法是 Array
对象放置方法,它会回去经过过滤的成分,不转移原先的数组。

8、Array some() 方法

let arr = [1,2,3];
let tt = arr.some(function(i){
 return i>1;
})
// true

some() 方法用于检查测试数组中的成分是还是不是满意钦点条件(函数提供),再次回到 boolean
值,不改变原数组。

9、Array every() 方法

let arr = [1,2,3];
let tt = arr.some(function(i){
 return i>1;
})
// 检测数组中元素是否都大于1
// false

every() 方法用于检查实验数组全体因素是还是不是都符合钦赐条件(通过函数提供),再次来到boolean 值,不改动原数组。

10、Array reduce()方法

let arr = [1,2,3];
let ad = arr.reduce(function(i,j){
 return i+j;
})
// 6

reduce()
方法接收2个函数作为累加器,数组中的种种值(从左到右)早先减弱,最后总结为1个值。

11、Array reduceRight()方法

let arr = [1,2,3];
let ad = arr.reduceRight(function(i,j){
 return i+j;
})
// 6

reduceRight()方法,和 reduce()
成效是如出1辙的,它是从数组的末尾处向前早先臆想。

12、for of 循环

let arr = ['name','age'];
for(let i of arr){
 console.log(i)
}
// name
// age

for of 循环是 Es陆 中新增的说话,用来代表 for in 和 forEach,它同意你遍历
Arrays(数组), Strings(字符串), Maps(映射),
Sets(集合)等可迭代(Iterable data)的数据结构,注意它的兼容性。

总结

上述正是自个儿计算的 Js 中广泛的循环遍历方法,随着 Es6标准的包容性越来越好,作者发现众多兑现方案逐步都不再须要了,比如
let、const 取代var 后,在某个情状下的闭包函数也就不存在了。

你或者感兴趣的篇章:

  • js 达成获取name
    相同的页面成分并循环遍历的法子
  • JavaScript中采纳for循环遍历数组
  • Javascript数组循环遍历之forEach详解
  • JS简单循环遍历json数组的章程
  • JavaScript中循环遍历Array与Map的不贰秘籍小结
  • JS
    使用for循环遍历子节点查找成分
  • JS使用for循环遍历Table的装有单元格内容
  • JS数组的遍历格局for循环与for…in
  • js数组循环遍历数组内全部因素的章程
  • javascript
    forEach通用循环遍历方法
网站地图xml地图