package f.u;

import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Set;

/* JADX INFO: Access modifiers changed from: package-private */
/* JADX INFO: compiled from: _Arrays.kt */
/* JADX INFO: loaded from: classes.dex */
public class f extends e {
    public static <T> boolean g(T[] tArr, T t) {
        f.z.d.k.e(tArr, "<this>");
        return i(tArr, t) >= 0;
    }

    public static <T> T h(T[] tArr) {
        f.z.d.k.e(tArr, "<this>");
        if (tArr.length == 0) {
            return null;
        }
        return tArr[0];
    }

    public static final <T> int i(T[] tArr, T t) {
        f.z.d.k.e(tArr, "<this>");
        int i2 = 0;
        if (t == null) {
            int length = tArr.length;
            while (i2 < length) {
                if (tArr[i2] == null) {
                    return i2;
                }
                i2++;
            }
            return -1;
        }
        int length2 = tArr.length;
        while (i2 < length2) {
            if (f.z.d.k.a(t, tArr[i2])) {
                return i2;
            }
            i2++;
        }
        return -1;
    }

    public static char j(char[] cArr) {
        f.z.d.k.e(cArr, "<this>");
        int length = cArr.length;
        if (length == 0) {
            throw new NoSuchElementException("Array is empty.");
        }
        if (length == 1) {
            return cArr[0];
        }
        throw new IllegalArgumentException("Array has more than one element.");
    }

    public static <T> T k(T[] tArr) {
        f.z.d.k.e(tArr, "<this>");
        if (tArr.length == 1) {
            return tArr[0];
        }
        return null;
    }

    public static final <T> T[] l(T[] tArr, Comparator<? super T> comparator) {
        f.z.d.k.e(tArr, "<this>");
        f.z.d.k.e(comparator, "comparator");
        if (tArr.length == 0) {
            return tArr;
        }
        T[] tArr2 = (T[]) Arrays.copyOf(tArr, tArr.length);
        f.z.d.k.d(tArr2, "copyOf(this, size)");
        e.f(tArr2, comparator);
        return tArr2;
    }

    public static <T> List<T> m(T[] tArr, Comparator<? super T> comparator) {
        f.z.d.k.e(tArr, "<this>");
        f.z.d.k.e(comparator, "comparator");
        return e.a(l(tArr, comparator));
    }

    public static final <T, C extends Collection<? super T>> C n(T[] tArr, C c2) {
        f.z.d.k.e(tArr, "<this>");
        f.z.d.k.e(c2, "destination");
        for (T t : tArr) {
            c2.add(t);
        }
        return c2;
    }

    public static final <T> Set<T> o(T[] tArr) {
        f.z.d.k.e(tArr, "<this>");
        int length = tArr.length;
        if (length == 0) {
            return g0.b();
        }
        if (length == 1) {
            return f0.a(tArr[0]);
        }
        LinkedHashSet linkedHashSet = new LinkedHashSet(b0.a(tArr.length));
        n(tArr, linkedHashSet);
        return linkedHashSet;
    }
}