# Longest Subarray of 1's After Deleting One Element

Given a binary array `nums`, you should delete one element from it.

Return the size of the longest non-empty subarray containing only 1's in the resulting array.

Return 0 if there is no such subarray.

**Example 1:**

```
Input: nums = [1,1,0,1]
Output: 3
Explanation: After deleting the number in position 2, [1,1,1] contains 3 numbers with value of 1's.
```

**Example 2:**

```
Input: nums = [0,1,1,1,0,1,1,0,1]
Output: 5
Explanation: After deleting the number in position 4, [0,1,1,1,1,1,0,1] longest subarray with value of 1's is [1,1,1,1,1].
```

**Example 3:**

```
Input: nums = [1,1,1]
Output: 2
Explanation: You must delete one element.
```

**Example 4:**

```
Input: nums = [1,1,0,0,1,1,1,0,1]
Output: 4
```

**Example 5:**

```
Input: nums = [0,0,0]
Output: 0
```

**Constraints:**

* `1 <= nums.length <= 10^5`
* `nums[i]` is either `0` or `1`.

```java
class Solution {
    public int longestSubarray(int[] nums) {
        boolean allOnes = true;
        for (int x : nums)
            if (x == 0) {
                allOnes = false;
                break;
            }
        if (allOnes)
            return nums.length - 1;
        int max = 0;
        int start = 0, end = 0;
        boolean deleted = false;
        while (end < nums.length) {
            if (nums[end] == 0) {
                if (deleted) {
                    while (nums[start] != 0)
                        start++;
                    start++;
                } else
                    deleted = true;
            }
            if (deleted)
                max = Math.max(max, end - start);
            else
                max = Math.max(max, end - start + 1);
            end++;
        }
        return max;
    }
}
```
