iOS学习1陆之OC集合遍历和数组排序,中的12种循环遍历方法

插入排序,是循环遍历三个冬日数组(例如有13个要素),把遍历出来的数值(第i个成分)插入到曾经排过各类的数组(那么些不变数组有10-i个因素)中。

1、集合遍历

1、for 循环

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

一.一聚众只存放引用类型的因素并且集合存放的时元素的引用(地址)
1.贰新循环遍历集合
Collection c = new ArrayList();
c.add(“one”);
c.add(“two”);
c.add(“three”);
c.add(“four”);
/*
* 新循环不是新的语法,jvm并不认同新循环。
*
新循环是编写翻译器承认的,当编写翻译器发今后行使新循环遍历集合时,会将代码改变为运用迭代器遍历,所以采用新循环遍历集合的进程中是无法通过聚合的点子增加和删除成分的。
*
*iOS学习1陆之OC集合遍历和数组排序,中的12种循环遍历方法。/
for (Object object : c) {
String str = (String)object;
System.out.println(str);
}
1.三集聚的操作
boolean addAll(collection c) 将给定的成团中的成分存入到当前聚集中
当前集合成分爆发了转移则赶回true
boolean containsAll(Collection c)
判断当前集结是不是含有给定集合中的具有因素
boolean removeAll(Collection c) 删除当前集合中与给定集合的等同成分
壹.捌回历集合–集合提供联合的遍历成分的格局:迭代器方式
聚集提供了用于获取遍历当前集合成分的办法:
java.util.Iterator
Iteartor
iterator()迭代器的接口,规定了遍历集合的措施,坚守的形式为:问,取,删的手续,个中删除成分不是必须操作。分歧的成团达成类都提供了3个得以遍历本身的迭代器达成类。大家无需记住它们的名字,当她们的Iterator看待即可。
boolean hasNext()判断集合是不是还有成分得以遍历
E next() 取出集合下三个得以遍历的成分
在使用迭代器遍历集合成分的经过中,不能经过集合的方法增加和删除成分不然会掀起迭代器遍历集合的百般,不过迭代器的remove能去除通过next方法取出的成分
一.五新循环–新循环又称之为:增强for循环,for
each,新循环的功效是用来遍历集合或数组—–新循环是JDK1.伍之后推出的多个新特点
采用新循环遍历集合:新循环并非新的语法,JVM并不认同新循环。新循环是编写翻译器认同的,当编写翻译器发以后应用新循环遍历集合时,会将代码改变为运用迭代器遍历。所以选用新循环遍历集合的过程中是不可能通过聚合的艺术增加和删除成分的。借使在新循环中除去成分会抛出十分。
一.陆泛型–一.伍过后推出的三个特征,泛型是编写翻译器承认泛型的实在类型是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提供了1对重载的add,remove方法也能够透过下标操作成分删除方法会再次回到贰个删减的要素。
一.玖拿走List子集:List<E> subList(int startindex,int endindex)
截取集合中钦点地点的要素,并赶回截取的要素;操作获取的子集的时候就相当于操作原有集合
1.10凑合转换为数组 —Collection中提供了将最近集合转换为贰个数组的点子
E[] array= c.toArray(new
E[c.size()]);将集纳转换为数组,传一个泛型数组并设置长度,如若设置长度不够也会重回八个恰恰和要素相等的数组,要是参数长度超过原有数组,则赶回输入长度的数组,未有元素的职分为null。
一.1一数组更换为汇集—List<String> list =
Arrays.asList(array);将数组转化为汇集,操作重临后的聚众等于操作原来的数组,并且不可能增加和删除成分,倘使想增日成分需求新建二个数组将再次来到数组的值传入并操作。
List<String> list一 = new
ArrayList<String>(list);这些措施能够在创设新数组的还要将原有数组的因素添加进去。

 

本人是初学者,如有更新不佳的,欢迎那位大神提议,多谢大家!

越多雅观现在更新,转发注脚!

壹.1聚集只存放引用类型的要素并且集合存放的时成分的引用(地址)
壹.2新循环遍历集合…

用三个 数组 举个例子:

 1> 遍历

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

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

  二种方法:一 for循环遍历; 二 NSEnumerator遍历; 3 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玖, 4, 3四, 5陆, 40, 5九,
60, 39, 1, 40, 90, 4捌 

 贰> for循环遍历

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

先是次巡回(i=0):壹, 8九, 四, 3四, 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=壹):  一, 8九, 四, 3四, 5六, 40, 5九, 60, 3玖, 1, 40, 90,
4八 

  贰 字典遍历

美高梅开户网址 ,   原理:先取得字典中具有的key,存款和储蓄到数组中,遍历数组依次取出每二个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=二):  一, 四, 8玖,
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
输出为字符串方式,而不是数组须要的数字下标,那表示在少数景况下,会爆发字符串运算,导致数据失实,比如:’5二’+一= ‘5二一’ 而不是我们必要的 伍3。

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

 3> NSEnumerator

别的 for in 循环的时候,不仅遍历本人的质量,还会找到 prototype
上去,所以最棒在循环体内加2个判定,就用
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循环结合把持有因素依次取出。

  叁 字典遍历

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

  注:字典中存放的数额是冬天的,未有反向枚举的概念。

  4 集合遍历

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         }

  叁 字典遍历

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

  肆 集合遍历

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

然后是 while 循环方法

2、数组排序

 数组是邯郸学步容器,由此集合中唯有数组才能排序。

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

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

  该类能够方便的落到实处对数组中的对象开始展览升序也许降序的排序。

  它能够把成分的某部属性作为key举办升序或降序的排序,各样NSSortDescriptor对象就是2个排序条件。

我们发现,它们得以兑现均等的功效,事实上它们底层的拍卖是同一的,但是 for
循环能够把定义、条件判断、自增自减操作放到二个规范里推行,代码看起来方便1些,仅此而已。

 二> 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 不可变数组

排序

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

 二 可变数组

排序

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
循环的二个变体,它首先实施二次操作,然后才开始展览标准化判断,是 true
的话再继续执行操作,是 false 的话循环甘休。

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

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

   注:SEL类型的参数comparator:必要传入三个回来结果是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:要求传入3个赶回结果是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,那样就能暂停循环了,借使你时不时用那几个方式,最棒自定义2个那样的
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()
方法再次回到3个新数组,数组中的成分为原始数组成分调用函数处理后的值。
注意: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()
方法接收四个函数作为累加器,数组中的每一个值(从左到右)开端缩减,最后总括为二个值。

11、Array reduceRight()方法

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

reduceRight()方法,和 reduce()
成效是均等的,它是从数组的末尾处向前起始总计。

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 山东中国广播公司大的大循环遍历方法,随着 Es陆标准的包容性越来越好,小编发觉众多得以实现方案逐步都不再供给了,比如
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地图