一道阿里面试题，求高手解答

Question

一个List放入多个person对象，每个person对象有name,age两个属性，现要求不准遍历List，取出name=张三，age=23的person对象

Answer 1

jdk8 stream

Answer 2

将集合的操作都利用stream来处理，牛逼的不要不要的
J8我感觉map的操作比以前方便很多

Answer 3

用stream 真可以搞定
https://www.cnblogs.com/andywithu/p/7404101.html
这个不就是C# 里面的LINQ吗

Answer 4

stream遍历就不是遍历了?
我翻了下源码,IteratorSpliterator这个里面就是集合类的迭代器阿里会问这么low的问题?

Answer 5

stream不也是遍历了么我有个比较笨的方法，我写一个方法，用递归不就行了。
参考

Answer 6

list设置hashcode ，用hashcode直接取数据

Answer 7

import java.util.ArrayList;
import java.util.List;public class test4 {
public static void main(String[] arg0) {
List<Person> list = new ArrayList<Person>();
Person p1 = new Person("lisi", 23);
Person p2 = new Person("wangwu", 23);
Person p3 = new Person("zhangsan", 23);
Person p4 = new Person("lisi", 25);
Person p5 = new Person("wangwu", 25);
Person p6 = new Person("zhangsan", 25);
list.add(p1);
list.add(p2);
list.add(p3);
list.add(p4);
list.add(p5);
list.add(p6);
System.out.println(list.get(list.indexOf(new Person("zhangsan", 23))));
}
}class Person {
private String name;
private int age; public Person(String name, int age) {
super();
this.name = name;
this.age = age;
} public char[] gethashcode(Person person) {
// TODO Auto-generated method stub
return null;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
} @Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
} @Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}

Answer 8

上面代码没有用到hashcode，只用到了重写了equals方法，事实上用的是index of 的查找功能，不知道符合要求么

Answer 9

list中有N个name=“张三”，age=23的person，，不遍历怎么取出完啊

Answer 10

如果真要是阿里的问题
那可以换个角度去理解这个问题
可以类比成数据库查找数据,List==表中数据,我们只需要额外加一个类似索引的数据结构,就可以避免全表搜索,也就是遍历或者用skip list再或者排序再二分查找法,也不算全部遍历了

Answer 11

index of也是遍历啊,真要不遍历就是做索引,不用全部遍历,遍历部分必不可少的

Answer 12

先排序，实现comparable接口的时候把要找的定义为最小的，经过一次排序后取第一个，因为排序方法不是遍历的，我是不是可以认为这个取出来的方法也不是遍历得到的

Answer 13

linq语句，这个可以

Answer 14

list又不是散列表，不要用hash算法了，而且还存在碰撞问题。先List按Person的age排序，排序后再二分查找，找到age等于23的数，如果找到，再比较name

Answer 15

List中如果是乱序的，而且不允许排序的话，除了遍历没有任何办法。或许有人说可以有***办法等等，但是在这种情况下，任何办法的本质都是遍历。当然如果说允许排序或者允许增加一些额外的内存开销的话，那就另当别论了。

Answer 16

list[0]= new person(){ name ='张三' , age=5};
list[1]= new person(){ name ='XX' , age=5};
list[...]= new person(){ name ='XX' , age=5}; list[0] //

Answer 17

先序列化，再用objectinputstream获取目标

Answer 18

import java.util.ArrayList;
class Person{
public Person(String name,int age){
this.name = name;
this.age = age;
}
@Override
public String toString(){
return String.format("Person[%s,%d]",name,age);
} @Override
public boolean equals(Object obj){
if(!(obj instanceof Person)){
return false;
}
Person person = (Person)obj;
return person.name.equals(name) && person.age == age;
} private String name;
private int age;
}public class Test{
public static void main(String[] args){
Person p1 = new Person("李四",28);
Person p2 = new Person("张三",25);
Person p3 = new Person("张三",23);
Person p4 = new Person("王五",24);
ArrayList<Person> people = new ArrayList<>();
people.add(p1);
people.add(p2);
people.add(p3);
people.add(p4); Person find = new Person("张三",23); int index = people.indexOf(find);
if(index > -1){
System.out.println("找到:" + people.get(index) + " 对应位置:" + index);
}else{
System.out.println("未找到:" + find);
}
}
}

Answer 19

stream  get到了

Answer 20

indexOf还是算了吧
    /**
     * Returns the index of the first occurrence of the specified element
     * in this list, or -1 if this list does not contain the element.
     * More formally, returns the lowest index <tt>i</tt> such that
     * <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>,
     * or -1 if there is no such index.
     */
    public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

Answer 21

感觉这是个脑筋急转弯，虽然说了用List，但是List只是个接口，我完全可以写一个基于hash的list。至于碰撞问题，增大列表长度可以减少碰撞。如果内存无限，hash算法合适，并且数组长度无限，理论上可以解决碰撞。package test.gt60;import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;public class Test69 { /**
 * @param args
 */
public static void main(String[] args) {
// TODO Auto-generated method stub

Person69 p1 = new Person69("p1", 11);
Person69 p2 = new Person69("p1", 11);
Person69 p3 = new Person69("p2", 11);
Person69 p4 = new Person69("p3", 11);
Person69 p5 = new Person69("p4", 11);

TestHashMapList list = new TestHashMapList();

list.add(p1.toString(), p1);
list.add(p2.toString(), p2);
list.add(p3.toString(), p3);
list.add(p4.toString(), p4);
list.add(p5.toString(), p5);

System.out.println(list.hashGet("p1_11"));

}}class Person69{
private String name;
private int age;

public Person69(String name, int age) {
super();
this.name = name;
this.age = age;
}

@Override
public String toString() {
// TODO Auto-generated method stub
return this.name + "_" + this.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;
}
}class TestHashMapList { private Map<String, List<Person69>> mapValue = new HashMap(2147483);

public void add(String str, Person69 person){
if(this.mapValue.containsKey(str)){
this.mapValue.get(str).add(person);
}else {
List temp = new ArrayList(16);
temp.add(person);
this.mapValue.put(str, temp);
}
}

public List<Person69> hashGet(String str){
return this.mapValue.get(str);
}
}