A response in C #, using the method of comparing the characters of a string :

public bool TodosIguais( int num ) {
  char comparar = num.ToString()[0];
  foreach( var n in num.ToString() ) {
    if ( comparar != n ) { return false; }
  }
  return true;
}

Editing

The same response, in a more compact way, using extension methods and LINQ :

//criar o classe
public static class Extencoes {
  public static bool TodosIguais( this int num ) {
    return num.ToString().All(c=>c.Equals(num.ToString().First()));
  }
}

//use-o
int numero = 5;
if ( numero.TodosIguais() ) { Console.WriteLine("Todos iguais."); }

• Get the number of decimal places of a given original O number using the formula Floor(Log10(numero)) + 1

Example:

O = 99999  
X = floor(log10(99999)) + 1 = 5 

• Generate a N number that has the digit 1 repeated X times

Example:

N = 11111

• Divide the original number O by N. If the division is integer, the number is a repetition.

Example:

O / N = 99999 / 11111 = 9.0 ; verdadeiro.

• Let X be the original number.
• Divide X by 10 and get the rest, call it R1.
• Repeat while X is non-zero
  • 3.1 Give R2 the rest of the division of X by 10.
  • 3.2 If R1 is other than R2, return false.
  • 3.2 Assign to X the quotient of the entire division of X by 10.
• Return true.

Note that this approach works only using math, without having to convert the number to string at any time.

See here the above algorithm implemented in javascript, including the test code:

function digitosIguais(x) {
  var r1 = x % 10;               // Passo 2.
  while (x > 0) {                // Passo 3.
    var r2 = x % 10;             // Passo 3.1.
    if (r2 !== r1) return false; // Passo 3.2.
    x = Math.floor(x / 10);      // Passo 3.3.
  }
  return true;                   // Passo 4.
}

function teste(numero) {
  document.writeln(numero + (digitosIguais(numero) ? "" : " não") + " tem todos os dígitos iguais.<br>");
}

teste(5555);
teste(88);
teste(9);
teste(11);
teste(0);
teste(123);
teste(765);
teste(9999998);
teste(800);
teste(404);

Click the blue button ► Run above to test and note the result.

Playing the charades of black magic:

1) A perl command that reads from STDIN and writes OK if all numbers are equal

perl -E 'say "OK" if <> =~ /^(\d)*$/'

2) an algorithm:

f(a) =  int((a*9+10)/10) % 10**(int(log10 a)) == 0

Javascript implementation of the provided formula in JJoao's answer .

It also includes the tests.

function digitosIguais(a) {
  return a === 0 || Math.floor((a * 9 + 10) / 10) % Math.pow(10, Math.floor(Math.log10(a))) === 0;
}

function teste(numero) {
  document.writeln(numero + (digitosIguais(numero) ? "" : " não") + " tem todos os dígitos iguais.<br>");
}

teste(5555);
teste(88);
teste(9);
teste(11);
teste(0);
teste(123);
teste(765);
teste(9999998);
teste(800);
teste(404);

Click the blue button ► Run above to test and note the result.

With regular expressions

Using regular expressions, it is easy to implement this idea in any language: ^(\d)*$

Explaining

^ frame the beginning of the string

(\d) get a numeric digit

the next character is equal to the digit I got

* this character can be repeated several times, or none

% frame_with% end of string (as I'm marking the beginning and ending, I guarantee there will be no extra characters in the string)

Implementing in javascript

I made a function to make it easier to use

function digitosIguais(numero) {
  return !!numero.toString().match(/^(\d)*$/);
}

Explaining

$ is to transform the result into boolean

!! is to convert the number to string, before applying the regular expression

Tests

console.log( digitosIguais(88888889) ); // => false
console.log( digitosIguais(88888888) ); // => true

Java 8 with chars stream

In Java 8, it's easy with streams :

boolean digitosIguais(Long numero) {
    return numero.toString().chars().distinct().count() == 1;
}

Traditional Loop Numbers Digits

Or, if you prefer, a traditional algorithm:

boolean digitosIguais(Long numero) {
    char[] digitos = numero.toString().toCharArray();
    for (int i = 1; i < digitos.length; i++) {
        if (digitos[0] != digitos[i]) return false;
    }
    return true;
}

Predefined digit sequences

Another idea would be to compare the number with a predefined sequence:

String[] repeticoes = {
    "11111111111111111111", 
    "22222222222222222222", 
    ..., 
    "99999999999999999999"
};

boolean digitosIguais(Long numero) {
    if (numero <= 0l) return false;
    String s = numero.toString();
    String repeticao = repeticoes[Integer.parseInt(numero.charAt(0))];
    return s.equals(repeticoes.substring(0, numero.length()));
}

Pre-calculation of possible combinations

Or even calculate the possible combinations and then identify if the number is in that set, which results in a practically constant search time:

Set<Long> repeticoes = new HashSet<>();
for (long i = 1L; i <= 9L; i++) {
    for (long j = i; j > 0 && j < 1000000000000000000L; j = j * 10L + i ) {
        repeticoes.add(j);
    }
}

boolean digitosIguais(Long numero) {
    return repeticoes.contains(numero);
}

The code above results in a set of 162 numbers.

• Algorithms implemented using Javascript.

  Algorithm # 1

  function digitsIguais (value) {   value = value.toString ();

  for (i = 1; i